David DPG's questions

My understanding is that when you want to create a new object in Javascript, it's best to use JSON notation:

let foo1 = {};
let foo2 = {};

foo1 = `Hola ${user}`;
foo2.name = user;

So I have been surprised when, when reviewing code that has been bequeathed to me, I have found something like:

let httpResponse = null;

if (condition) {
    httpResponse = 'Error processing request'
} else {
    httpResponse = JSON.parse(data)
}

Why have my peers put null to initialize the object? Are there differences between both ways?

Context

We have an offer view on the front end that looks like this:

<table>
  <tbody>
    <tr *ngFor="let offer of offerList">
      <td>{{offer[0].appArea.creationDate}}</td>
      <td>{{offer[0].client.id}}</td>
      <td>{{offer[0].client.name}}</td>
      ...
    </tr>
  </tbody>
</table>

This offerlistis collected from a database in a less traditional way : only the ids and a hash are stored in the database, with which an IPFS network is accessed, which is the one that has the data of the offers.

In addition, it is set up in such a way that, to obtain an array of noffers, exactly n + 1requests are made: the first one brings the array with the ids and hash, and the nfollowing ones are the result of iterating through that array and asking the IPFS for the data:

export class OffersComponent implements OnInit{

  offerList: Array<any> = []

  loadOffersForClient(email) {

    this.offerService.getOwnerInitialOffers(email).subscribe(
      (initOfferResponse) => {
        initOfferResponse[0].offers.map((item) => {

          this.offerService.getOfferFileData(item.hashId).subscribe(
            (itemResponse) => {
              this.offerList.push([itemResponse, item, ]);
            }
          );
        });
      }
    );
  }
}

The service makes simple calls with the http client:

export class OfferService {

  constructor(private http: HttpClient) { }

  getOwnerInitialOffers(email: string) {
    return this.http.post<any>(`path/to/offers/${email}`); // se traen datos por post porque asi esta especificada la api
  }

  getOfferFileData(hashId: string) {
    return this.http.get<any>(`path/to/file/server/${hashId}`);
  }
}

Problem

The requirements have changed and we need to order the array. By date, to be more exact. The problem comes from the fact that I am not sure when I can order the array being sure that the elements have finished filling .

Until now, it had occurred to me to order it by brute force, every time a new request is launched:

this.offerService.getOfferFileData(item.hashId).subscribe(
  (itemResponse) => {
    this.offerList.push([itemResponse, item, ]);
    this.offerList.sort((a, b) => {
      const firstDate = a[0].applicationArea.creationDateTime;
      const secondDate = b[0].applicationArea.creationDateTime;
      return (firstDate < secondDate) ? 1 : ((firstDate > secondDate) ? -1 : 0);
    });
  }
);

Aside from being incredibly inefficient, it doesn't work, I understand that the items haven't been loaded by the time the sort occurs.

How can I make sure that the array has already been loaded, so that I can sort only once and without the danger of new elements entering?

Problem

I have a repository with several different files, and I have had to modify several.

Since each one is a configuration file for different projects, my intention was to create a branch for each of them, like this (alphabetical order is the time order of commits) :

a--b--c (develop)
      |\
      | d--e--f (feature/1)
      |\
      | g--h--i (feature/2)
       \
        j--k--l (feature/3)

The problem is that I forgot to create the branches from develop, so in the end I have this:

a--b--c (develop)
       \
        d--e--f (feature/1)
               \
                g--h--i (feature/2)
                       \
                        j--k--l (feature/3)

And to top it all off, I've already done it pushremotely.

What have I thought of doing?

I have thought about doing rebase:

git rebase --onto develop feature/3 feature/4 
git rebase --onto develop feature/2 feature/3
... 

But I understand that this could be a problem when redoing pushremotely, because the tree in remote would not be the same as the one in local.

My other option was to delete both the local and remote branches and do it all over again. It's really only one file per branch, and it's only a couple of lines per file, so I could do it in a couple of hours, but I'm sure git has some way around this.

what do i want to get

I want the branches that I have created to all be born from the same commit develop(the last one) and that the changes I made in the first ones are not reflected in the last ones, always trying to make sure there are no problems when pushing.

By way of consideration, in these branches I am working only myself.

I was messing around in CodeFigths and I got to a situation like this:

int makeArrayConsecutive2(int[] statues) {    
    Set<Integer> statueSet = new TreeSet<>(Arrays.asList(statues));
    for (int statue : statueSet) {
        System.out.println(statue);
    }
}

Logically, I have noticed that the compiler is doing a lot of Autoboxing and Unboxing, so the question has arisen:

Should I force unbox a collection of Wrappers, or use the Wrapper directly? What are the advantages and disadvantages of each option?