Najlepsze praktyki dla przesyłania wielu obrazów z klienta do serwera

głosy
2

Ja przesyłania wielu obrazów z mojego klienta przeglądarki (Aws s3 direct form upload/stream),w górę do 25 imagesnaraz.

Przed przesyłać obrazy kompresowane mam je, aby je mniejsze.

Ale teraz nie jestem pewien, czy powinienem przesłać wszystkie zdjęcia naraz lub jeden raz przy użyciu rekursji

Przykład 1, zapętlenie przez moich obrazów i przesyłając je wszystkie na raz

var imagesUploaded = [];
      for (var i = 0; i < _this.imgArray.length; i++) {

        var params = {
          Key: 'images/' + id + '/' + _this.imgArray[i].name,
          ContentType: 'image/jpeg',
          Body: _this.imgArray[i],
          ACL: 'public-read'
        };

        bucket.putObject(params, function(err, data) {
          if (err) {
            console.log(err);
          } else {
            //Run callback when all images are uploaded
            imagesUploaded.push(dummy); //Just to end loop when all images are done
            if (imagesUploaded.length === _this.imgArray.length) {
              //Done uploading all.
              callback();
            }
          }
        });

      }

Przykład 2 przy użyciu rekursji. Przesłać jedno zdjęcie w czasie i rozpocząć kolejny raz poprzedni przesyłanie odbywa.

func recursionUpload() {

.. some other code

var s3 = new AWS.S3({apiVersion: '2006-03-01', region: 'us-west-2'});
var params = {
  Bucket: 'bucket',
  Key: 'example2.txt',
  Body: 'Uploaded text using the promise-based method!'
};
var putObjectPromise = s3.putObject(params).promise();
putObjectPromise.then(function(data) {
  console.log('Success');

  //Upload next image
  recursionUpload()


}).catch(function(err) {
  console.log(err);
});


}

Czuję, że Przykład 1 jest o wiele szybciej, ponieważ będzie załadować wielu obrazów w tym samym czasie, ale jestem obawiaj się, że może to potrwać tworzyć zbyt wiele pamięci przeglądarki. Więc których przykładem jest „najlepsze praktyki”

Utwórz 11/02/2018 o 10:42
użytkownik
W innych językach...                            


3 odpowiedzi

głosy
-3

Rekurencja jest zwykle najlepiej unikać, ponieważ ma tendencję do albo dokonać przebieg programu z pamięci lub konieczności przerwany, gdy natrafi limit rekurencji.

Przesyłanie plików (wiele) jest najlepiej zrobić z ftp.

Odpowiedział 11/02/2018 o 10:52
źródło użytkownik

głosy
0

Najlepszą praktyką jest za pomocą kolejki. Pozwoliłoby to na wprowadzenie nowych plików do niego nawet wtedy, gdy przesyłka jest już uruchomiony.

var queue = [];

function put(file) {
    queue.push(file);
}

function next() {
    return queue.shift();
}

function start() {
    var nextFile;
    while((nextFile = next()) !== undefined) {
        // upload nextFile
    }
}
Odpowiedział 11/02/2018 o 11:18
źródło użytkownik

głosy
0

Można użyć Promise.all () do tego:

const s3 = new AWS.S3({apiVersion: "2006-03-01"});

const uploadImages = function uploadImages(images) {
  return Promise.all(images.map((img) => {
    const params = {
      Bucket: "your-bucket-name",
      Key: img.FileName,
      Body: img.Data
    };
    return s3.putObject(params).promise();
  }));
};

uploadImages(_this.imgArray)
  .then((responses) => {
    console.log(responses);
  })
  .catch((err) => {
    console.error(err.message);
  });
Odpowiedział 11/02/2018 o 11:45
źródło użytkownik

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more