Caricamento di file angolare


193

Sono un principiante con Angular, voglio sapere come creare la parte di caricamento di Angular 5 File , sto cercando di trovare tutorial o documenti, ma non vedo nulla da nessuna parte. Qualche idea per questo? E ho provato i file ng4 ma non funziona per Angular 5


2
quindi vuoi trascinare e rilasciare o semplicemente Choose Filecaricare btn? Bdw in entrambi i casi è sufficiente caricare utilizzando FormData
Dhyey il

4
Dai un'occhiata a primeng, lo sto usando da un po 'e funziona con angular v5. primefaces.org/primeng/#/fileupload
Bunyamin Coskuner il

Per coloro che hanno solo bisogno di caricare JSON al cliente, verificare questa domanda: stackoverflow.com/questions/54971238/...
AnthonyW

Risposte:


427

Ecco un esempio funzionante per il caricamento di file su api:

Passaggio 1: modello HTML (file-upload.component.html)

Definire un semplice tag di input di tipo file. Aggiungi una funzione a (change)-event per la gestione della scelta dei file.

<div class="form-group">
    <label for="file">Choose File</label>
    <input type="file"
           id="file"
           (change)="handleFileInput($event.target.files)">
</div>

Passaggio 2: Gestione del caricamento in TypeScript (file-upload.component.ts)

Definire una variabile predefinita per il file selezionato.

fileToUpload: File = null;

Crea la funzione che usi in caso (change)di tag di input del file:

handleFileInput(files: FileList) {
    this.fileToUpload = files.item(0);
}

Se si desidera gestire la selezione multipla, è possibile scorrere attraverso questo array di file.

Ora crea la funzione di caricamento dei file chiamandoti file-upload.service:

uploadFileToActivity() {
    this.fileUploadService.postFile(this.fileToUpload).subscribe(data => {
      // do something, if upload success
      }, error => {
        console.log(error);
      });
  }

Passaggio 3: Servizio di caricamento file (file-upload.service.ts)

Caricando un file tramite il metodo POST dovresti usare FormData, perché così puoi aggiungere il file alla richiesta http.

postFile(fileToUpload: File): Observable<boolean> {
    const endpoint = 'your-destination-url';
    const formData: FormData = new FormData();
    formData.append('fileKey', fileToUpload, fileToUpload.name);
    return this.httpClient
      .post(endpoint, formData, { headers: yourHeadersConfig })
      .map(() => { return true; })
      .catch((e) => this.handleError(e));
}

Quindi, questo è un esempio di lavoro molto semplice, che uso quotidianamente nel mio lavoro.


6
@ Katie hai abilitato i polyfill?
Gregor Doroschenko

2
@GregorDoroschenko Stavo cercando di utilizzare un modello con informazioni aggiuntive sul file e ho dovuto farlo per farlo funzionare: const invFormData: FormData = new FormData(); invFormData.append('invoiceAttachment', invoiceAttachment, invoiceAttachment.name); invFormData.append('invoiceInfo', JSON.stringify(invoiceInfo)); il controller ha due parametri corrispondenti, ma ho dovuto analizzare il JSON nel controller. Il mio controller Core 2 non rileva automaticamente il modello nel parametro. Il mio progetto originale era un modello con una proprietà file, ma non riuscivo a farlo funzionare
Papa Stahl,

1
@GregorDoroschenko Ho provato questo codicecreateContrat(fileToUpload: File, newContrat: Contrat): Observable<boolean> { let headers = new Headers(); const endpoint = Api.getUrl(Api.URLS.createContrat)); const formData: FormData =new FormData(); formData.append('fileKey', fileToUpload, FileToUpload.name); let body newContrat.gup(this.auth.getCurrentUser().token); return this.http .post(endpoint, formData, body) .map(() => { return true; }) }
OnnaB il

1
@GregorDoroschenko E per me non funziona. Content-Disposition: form-data; name="fileKey"; filename="file.docx" Content-Type: application/octet-stream <file>
Pubblica

1
@OnnaB Se si utilizza FormData per il file e per altre proprietà, è necessario analizzare il file e altre proprietà come FormData. Non è possibile utilizzare FormData e body contemporaneamente.
Gregor Doroschenko,

23

In questo modo implemento il file di caricamento nell'API Web nel progetto.

Condivido per chi riguarda.

const formData: FormData = new FormData();
formData.append('Image', image, image.name);
formData.append('ComponentId', componentId);
return this.http.post('/api/dashboard/UploadImage', formData);

Passo dopo passo

API Web ASP.NET

[HttpPost]
[Route("api/dashboard/UploadImage")]
public HttpResponseMessage UploadImage() 
{
    string imageName = null;
    var httpRequest = HttpContext.Current.Request;
    //Upload Image
    var postedFile = httpRequest.Files["Image"];
    //Create custom filename
    if (postedFile != null)
    {
        imageName = new String(Path.GetFileNameWithoutExtension(postedFile.FileName).Take(10).ToArray()).Replace(" ", "-");
        imageName = imageName + DateTime.Now.ToString("yymmssfff") + Path.GetExtension(postedFile.FileName);
        var filePath = HttpContext.Current.Server.MapPath("~/Images/" + imageName);
        postedFile.SaveAs(filePath);
    }
}

Modulo HTML

<form #imageForm=ngForm (ngSubmit)="OnSubmit(Image)">

    <img [src]="imageUrl" class="imgArea">
    <div class="image-upload">
        <label for="file-input">
            <img src="upload.jpg" />
        </label>

        <input id="file-input" #Image type="file" (change)="handleFileInput($event.target.files)" />
        <button type="submit" class="btn-large btn-submit" [disabled]="Image.value=='' || !imageForm.valid"><i
                class="material-icons">save</i></button>
    </div>
</form>

File TS per utilizzare l'API

OnSubmit(Image) {
    this.dashboardService.uploadImage(this.componentId, this.fileToUpload).subscribe(
      data => {
        console.log('done');
        Image.value = null;
        this.imageUrl = "/assets/img/logo.png";
      }
    );
  }

Servizio TS

uploadImage(componentId, image) {
        const formData: FormData = new FormData();
        formData.append('Image', image, image.name);
        formData.append('ComponentId', componentId);
        return this.http.post('/api/dashboard/UploadImage', formData);
    }

1
Qual è la tua strada non inviare intestazioni?
Shalom Dahan,

14

Il metodo molto semplice e veloce sta usando ng2-file-upload .

Installa il caricamento di file ng2 tramite npm. npm i ng2-file-upload --save

Al primo modulo di importazione nel modulo.

import { FileUploadModule } from 'ng2-file-upload';

Add it to [imports] under @NgModule:
imports: [ ... FileUploadModule, ... ]

markup:

<input ng2FileSelect type="file" accept=".xml" [uploader]="uploader"/>

Nei tuoi principi:

import { FileUploader } from 'ng2-file-upload';
...
uploader: FileUploader = new FileUploader({ url: "api/your_upload", removeAfterUpload: false, autoUpload: true });

È il più semplice utilizzo di questo. Per conoscere tutta la potenza di questo vedi demo


4
come ottenere risposta quando l'immagine viene caricata? quale sarà la risposta, nella documentazione manca questa parte.
Muhammad Shahzad,

7

Sto usando Angular 5.2.11, mi piace la soluzione fornita da Gregor Doroschenko, tuttavia ho notato che il file caricato è di zero byte, ho dovuto apportare una piccola modifica per farlo funzionare per me.

postFile(fileToUpload: File): Observable<boolean> {
  const endpoint = 'your-destination-url';
  return this.httpClient
    .post(endpoint, fileToUpload, { headers: yourHeadersConfig })
    .map(() => { return true; })
    .catch((e) => this.handleError(e));
}

Le seguenti righe (formData) non hanno funzionato per me.

const formData: FormData = new FormData();
formData.append('fileKey', fileToUpload, fileToUpload.name);

https://github.com/amitrke/ngrke/blob/master/src/app/services/fileupload.service.ts


6

Ok, poiché questo thread appare tra i primi risultati di google e per gli altri utenti che hanno la stessa domanda, non è necessario reinventare la ruota come indicato da trueboroda c'è la libreria di caricamento file ng2 che semplifica questo processo di caricamento di un file con angolare 6 e 7 tutto ciò che devi fare è:

Installa la CLI angolare più recente

yarn add global @angular/cli

Quindi installare rx-compat per motivi di compatibilità

npm install rxjs-compat --save

Installa ng2-file-upload

npm install ng2-file-upload --save

Importa la Direttiva FileSelectDirective nel tuo modulo.

import { FileSelectDirective } from 'ng2-file-upload';

Add it to [declarations] under @NgModule:
declarations: [ ... FileSelectDirective , ... ]

Nel tuo componente

import { FileUploader } from 'ng2-file-upload/ng2-file-upload';
...

export class AppComponent implements OnInit {

   public uploader: FileUploader = new FileUploader({url: URL, itemAlias: 'photo'});
}

Modello

<input type="file" name="photo" ng2FileSelect [uploader]="uploader" />

Per una migliore comprensione è possibile controllare questo link: Come caricare un file con Angular 6/7


1
Grazie per il link Il caricamento funziona bene sul desktop, ma non riesco per tutta la vita a fare in modo che i caricamenti funzionino su dispositivi mobili come iOS. Posso selezionare un file dal rullino fotografico ma quando lo carico non riesce sempre. Qualche idea? Cordiali saluti, eseguendo questo in Safari mobile, non in un'app installata.
ScottN,

1
Ciao @ScottN e sei il benvenuto, forse il problema proviene dal browser che stai utilizzando? l'hai provato con un altro?
Mohamed Makkaoui,

1
Ciao @Mohamed Makkaoui grazie per la risposta. L'ho provato in Chrome su iOS e sempre lo stesso risultato. Sono curioso di sapere se si tratta di un problema di intestazione durante la pubblicazione sul server? Sto usando un WebAPI personalizzato scritto in .Net e NON AWS ​​FYI.
ScottN,

1
Ciao @ScottN non saremo in grado di sapere se si tratta di un problema di intestazione fino a quando non esegui il debug del codice utilizzando questo link developers.google.com/web/tools/chrome-devtools/… e vedi quale messaggio di errore ricevi.
Mohamed Makkaoui,

6

Personalmente sto facendo questo usando ngx-material-file-input per il front-end e Firebase per il back-end. Più precisamente C forte Storage per Firebase per il back-end combinato con Cloud Firestore. Di seguito un esempio, che limita il file a non essere superiore a 20 MB e accetta solo determinate estensioni di file. Sto anche usando Cloud Firestore per archiviare i collegamenti ai file caricati, ma puoi saltare questo.

contact.component.html

<mat-form-field>
  <!--
    Accept only files in the following format: .doc, .docx, .jpg, .jpeg, .pdf, .png, .xls, .xlsx. However, this is easy to bypass, Cloud Storage rules has been set up on the back-end side.
  -->
  <ngx-mat-file-input
    [accept]="[
      '.doc',
      '.docx',
      '.jpg',
      '.jpeg',
      '.pdf',
      '.png',
      '.xls',
      '.xlsx'
    ]"
    (change)="uploadFile($event)"
    formControlName="fileUploader"
    multiple
    aria-label="Here you can add additional files about your project, which can be helpeful for us."
    placeholder="Additional files"
    title="Additional files"
    type="file"
  >
  </ngx-mat-file-input>
  <mat-icon matSuffix>folder</mat-icon>
  <mat-hint
    >Accepted formats: DOC, DOCX, JPG, JPEG, PDF, PNG, XLS and XLSX,
    maximum files upload size: 20 MB.
  </mat-hint>
  <!--
    Non-null assertion operators are required to let know the compiler that this value is not empty and exists.
  -->
  <mat-error
    *ngIf="contactForm.get('fileUploader')!.hasError('maxContentSize')"
  >
    This size is too large,
    <strong
      >maximum acceptable upload size is
      {{
        contactForm.get('fileUploader')?.getError('maxContentSize')
          .maxSize | byteFormat
      }}</strong
    >
    (uploaded size:
    {{
      contactForm.get('fileUploader')?.getError('maxContentSize')
        .actualSize | byteFormat
    }}).
  </mat-error>
</mat-form-field>

contact.component.ts (parte validatore dimensioni)

import { FileValidator } from 'ngx-material-file-input';
import { FormBuilder, FormGroup, Validators } from '@angular/forms';

/**
 * @constructor
 * @description Creates a new instance of this component.
 * @param  {formBuilder} - an abstraction class object to create a form group control for the contact form.
 */
constructor(
  private angularFirestore: AngularFirestore,
  private angularFireStorage: AngularFireStorage,
  private formBuilder: FormBuilder
) {}

public maxFileSize = 20971520;
public contactForm: FormGroup = this.formBuilder.group({
    fileUploader: [
      '',
      Validators.compose([
        FileValidator.maxContentSize(this.maxFileSize),
        Validators.maxLength(512),
        Validators.minLength(2)
      ])
    ]
})

contact.component.ts (parte del file uploader)

import { AngularFirestore } from '@angular/fire/firestore';
import {
  AngularFireStorage,
  AngularFireStorageReference,
  AngularFireUploadTask
} from '@angular/fire/storage';
import { catchError, finalize } from 'rxjs/operators';
import { throwError } from 'rxjs';

public downloadURL: string[] = [];
/**
* @description Upload additional files to Cloud Firestore and get URL to the files.
   * @param {event} - object of sent files.
   * @returns {void}
   */
  public uploadFile(event: any): void {
    // Iterate through all uploaded files.
    for (let i = 0; i < event.target.files.length; i++) {
      const randomId = Math.random()
        .toString(36)
        .substring(2); // Create random ID, so the same file names can be uploaded to Cloud Firestore.

      const file = event.target.files[i]; // Get each uploaded file.

      // Get file reference.
      const fileRef: AngularFireStorageReference = this.angularFireStorage.ref(
        randomId
      );

      // Create upload task.
      const task: AngularFireUploadTask = this.angularFireStorage.upload(
        randomId,
        file
      );

      // Upload file to Cloud Firestore.
      task
        .snapshotChanges()
        .pipe(
          finalize(() => {
            fileRef.getDownloadURL().subscribe((downloadURL: string) => {
              this.angularFirestore
                .collection(process.env.FIRESTORE_COLLECTION_FILES!) // Non-null assertion operator is required to let know the compiler that this value is not empty and exists.
                .add({ downloadURL: downloadURL });
              this.downloadURL.push(downloadURL);
            });
          }),
          catchError((error: any) => {
            return throwError(error);
          })
        )
        .subscribe();
    }
  }

storage.rules

rules_version = '2';
service firebase.storage {
  match /b/{bucket}/o {
    match /{allPaths=**} {
        allow read; // Required in order to send this as attachment.
      // Allow write files Firebase Storage, only if:
      // 1) File is no more than 20MB
      // 2) Content type is in one of the following formats: .doc, .docx, .jpg, .jpeg, .pdf, .png, .xls, .xlsx.
      allow write: if request.resource.size <= 20 * 1024 * 1024
        && (request.resource.contentType.matches('application/msword')
        || request.resource.contentType.matches('application/vnd.openxmlformats-officedocument.wordprocessingml.document')
        || request.resource.contentType.matches('image/jpg')
        || request.resource.contentType.matches('image/jpeg')
        || request.resource.contentType.matches('application/pdf')
                || request.resource.contentType.matches('image/png')
        || request.resource.contentType.matches('application/vnd.ms-excel')
        || request.resource.contentType.matches('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'))
    }
  }
}

2
Hai toString()un bell'aspetto , ma perché hai bisogno della dichiarazione contactForm?
trungk18,

1
@ trungk18 controlla ancora una volta, e hai ragione toString()è inutile, ho modificato la mia risposta. Per coloro che avrebbero letto questo commento, alla fine di fileUploaderin contact.component.ts ho avuto ])].toString()}). Ora è semplicemente: ])]}).
Daniel Danielecki,

5
  1. HTML

    <div class="form-group">
      <label for="file">Choose File</label><br /> <input type="file" id="file" (change)="uploadFiles($event.target.files)">
    </div>

    <button type="button" (click)="RequestUpload()">Ok</button>
  1. ts File
public formData = new FormData();
ReqJson: any = {};

uploadFiles( file ) {
        console.log( 'file', file )
        for ( let i = 0; i < file.length; i++ ) {
            this.formData.append( "file", file[i], file[i]['name'] );
        }
    }

RequestUpload() {
        this.ReqJson["patientId"] = "12"
        this.ReqJson["requesterName"] = "test1"
        this.ReqJson["requestDate"] = "1/1/2019"
        this.ReqJson["location"] = "INDIA"
        this.formData.append( 'Info', JSON.stringify( this.ReqJson ) )
            this.http.post( '/Request', this.formData )
                .subscribe(( ) => {                 
                });     
    }
  1. Backend Spring (file java)

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

@Controller
public class Request {
    private static String UPLOADED_FOLDER = "c://temp//";

    @PostMapping("/Request")
    @ResponseBody
    public String uploadFile(@RequestParam("file") MultipartFile file, @RequestParam("Info") String Info) {
        System.out.println("Json is" + Info);
        if (file.isEmpty()) {
            return "No file attached";
        }
        try {
            // Get the file and save it somewhere
            byte[] bytes = file.getBytes();
            Path path = Paths.get(UPLOADED_FOLDER + file.getOriginalFilename());
            Files.write(path, bytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "Succuss";
    }
}

Dobbiamo creare una cartella "temp" nell'unità C, quindi questo codice stamperà Json nella console e salverà il file caricato nella cartella creata


Come recuperiamo quel file? Hai qualche consiglio a riguardo?
Siddharth Choudhary,

Anche il mio server di primavera funziona su 8080 e quello angolare su 3000. Ora quando segnalo server_url come localhost: 8080 / api / uploadForm dice che cors non è permesso!
Siddharth Choudhary,

byte [] bytes = file.getBytes (); ti darà il flusso di byte..puoi convertirlo in file, per problemi di cors puoi trovare la soluzione in google
Shafeeq Mohammed

5

Innanzitutto, devi configurare HttpClient nel tuo progetto angolare.

Aprire il file src / app / app.module.ts, importare HttpClientModule e aggiungerlo all'array import del modulo come segue:

import { BrowserModule } from '@angular/platform-browser';  
import { NgModule } from '@angular/core';
import { AppRoutingModule } from './app-routing.module';  
import { AppComponent } from './app.component';  
import { HttpClientModule } from '@angular/common/http';

@NgModule({  
  declarations: [  
    AppComponent,  
  ],  
  imports: [  
    BrowserModule,  
    AppRoutingModule,  
    HttpClientModule  
  ],  
  providers: [],  
  bootstrap: [AppComponent]  
})  
export class AppModule { }

Quindi, genera un componente:

$ ng generate component home

Successivamente, genera un servizio di caricamento:

$ ng generate service upload

Quindi, apri il file src / app / upload.service.ts come segue:

import { HttpClient, HttpEvent, HttpErrorResponse, HttpEventType } from  '@angular/common/http';  
import { map } from  'rxjs/operators';

@Injectable({  
  providedIn: 'root'  
})  
export class UploadService { 
    SERVER_URL: string = "https://file.io/";  
    constructor(private httpClient: HttpClient) { }
    public upload(formData) {

      return this.httpClient.post<any>(this.SERVER_URL, formData, {  
         reportProgress: true,  
         observe: 'events'  
      });  
   }
}

Quindi, apri il file src / app / home / home.component.ts e inizia aggiungendo le seguenti importazioni:

import { Component, OnInit, ViewChild, ElementRef  } from '@angular/core';
import { HttpEventType, HttpErrorResponse } from '@angular/common/http';
import { of } from 'rxjs';  
import { catchError, map } from 'rxjs/operators';  
import { UploadService } from  '../upload.service';

Successivamente, definire le variabili fileUpload e file e iniettare UploadService come segue:

@Component({  
  selector: 'app-home',  
  templateUrl: './home.component.html',  
  styleUrls: ['./home.component.css']  
})  
export class HomeComponent implements OnInit {
    @ViewChild("fileUpload", {static: false}) fileUpload: ElementRef;files  = [];  
    constructor(private uploadService: UploadService) { }

Quindi, definire il metodo uploadFile ():

uploadFile(file) {  
    const formData = new FormData();  
    formData.append('file', file.data);  
    file.inProgress = true;  
    this.uploadService.upload(formData).pipe(  
      map(event => {  
        switch (event.type) {  
          case HttpEventType.UploadProgress:  
            file.progress = Math.round(event.loaded * 100 / event.total);  
            break;  
          case HttpEventType.Response:  
            return event;  
        }  
      }),  
      catchError((error: HttpErrorResponse) => {  
        file.inProgress = false;  
        return of(`${file.data.name} upload failed.`);  
      })).subscribe((event: any) => {  
        if (typeof (event) === 'object') {  
          console.log(event.body);  
        }  
      });  
  }

Successivamente, definisci il metodo uploadFiles () che può essere utilizzato per caricare più file di immagine:

private uploadFiles() {  
    this.fileUpload.nativeElement.value = '';  
    this.files.forEach(file => {  
      this.uploadFile(file);  
    });  
}

Quindi, definire il metodo onClick ():

onClick() {  
    const fileUpload = this.fileUpload.nativeElement;fileUpload.onchange = () => {  
    for (let index = 0; index < fileUpload.files.length; index++)  
    {  
     const file = fileUpload.files[index];  
     this.files.push({ data: file, inProgress: false, progress: 0});  
    }  
      this.uploadFiles();  
    };  
    fileUpload.click();  
}

Successivamente, dobbiamo creare il modello HTML della nostra interfaccia utente per il caricamento delle immagini. Apri il file src / app / home / home.component.html e aggiungi il seguente contenuto:

       <div style="text-align:center; margin-top: 100px; ">

        <button mat-button color="warn" (click)="onClick()">  
            Upload  
        </button>  
    <input type="file" #fileUpload id="fileUpload" name="fileUpload" multiple="multiple" accept="image/*" style="display:none;" /></div>

Dai un'occhiata a questo tutorial e a questo post


4

Esempio completo di caricamento di file utilizzando Angular e nodejs (express)

Codice HTML

            <div class="form-group">
                <label for="file">Choose File</label><br/>
                <input type="file" id="file" (change)="uploadFile($event.target.files)" multiple>
            </div>

Codice componente TS

uploadFile(files) {
    console.log('files', files)
        var formData = new FormData();

    for(let i =0; i < files.length; i++){
      formData.append("files", files[i], files[i]['name']);
        }

    this.httpService.httpPost('/fileUpload', formData)
      .subscribe((response) => {
        console.log('response', response)
      },
        (error) => {
      console.log('error in fileupload', error)
       })
  }

Codice nodo Js

FileUpload API controller

function start(req, res) {
fileUploadService.fileUpload(req, res)
    .then(fileUploadServiceResponse => {
        res.status(200).send(fileUploadServiceResponse)
    })
    .catch(error => {
        res.status(400).send(error)
    })
}

module.exports.start = start

Carica il servizio usando la muggitrice

const multer = require('multer') // import library
const moment = require('moment')
const q = require('q')
const _ = require('underscore')
const fs = require('fs')
const dir = './public'

/** Store file on local folder */
let storage = multer.diskStorage({
destination: function (req, file, cb) {
    cb(null, 'public')
},
filename: function (req, file, cb) {
    let date = moment(moment.now()).format('YYYYMMDDHHMMSS')
    cb(null, date + '_' + file.originalname.replace(/-/g, '_').replace(/ /g,     '_'))
}
})

/** Upload files  */
let upload = multer({ storage: storage }).array('files')

/** Exports fileUpload function */
module.exports = {
fileUpload: function (req, res) {
    let deferred = q.defer()

    /** Create dir if not exist */
    if (!fs.existsSync(dir)) {
        fs.mkdirSync(dir)
        console.log(`\n\n ${dir} dose not exist, hence created \n\n`)
    }

    upload(req, res, function (err) {
        if (req && (_.isEmpty(req.files))) {
            deferred.resolve({ status: 200, message: 'File not attached', data: [] })
        } else {
            if (err) {
                deferred.reject({ status: 400, message: 'error', data: err })
            } else {
                deferred.resolve({
                    status: 200,
                    message: 'File attached',
                    filename: _.pluck(req.files,
                        'filename'),
                    data: req.files
                })
            }
        }
    })
    return deferred.promise
}
}

1
da dove proviene httpService?
James

@James httpService è un modulo http angolare per effettuare chiamate HTTP al server. Puoi utilizzare qualsiasi servizio http che desideri.import {HttpClientModule} da '@ angular / common / http';
Rohit Parte

2

Prova questo

Installare

npm install primeng --save

Importare

import {FileUploadModule} from 'primeng/primeng';

html

<p-fileUpload name="myfile[]" url="./upload.php" multiple="multiple"
    accept="image/*" auto="auto"></p-fileUpload>

1
mi sono stancato di usare l'esempio sopra. Ma sto ottenendo ./upload.php non trovato.
Sandeep Kamath,

2
Dovresti fornire il tuo URL dove dovrebbe essere caricato invece di upload.php @sandeep kamath
Vignesh

1
@Vignesh grazie per la tua risposta. Ma ho scoperto che non do affatto l'attributo url per caricare il file, dovrebbe essere quello predefinito.
Sandeep Kamath,

1
Puoi spiegare come possiamo ricevere il file in php se stiamo facendo questo metodo.
Shaikh Arbaaz,

2

In angolare 7/8/9

Link alla fonte

inserisci qui la descrizione dell'immagine

Utilizzo del modulo Bootstrap

<form>
    <div class="form-group">
        <fieldset class="form-group">

            <label>Upload Logo</label>
            {{imageError}}
            <div class="custom-file fileInputProfileWrap">
                <input type="file" (change)="fileChangeEvent($event)" class="fileInputProfile">
                <div class="img-space">

                    <ng-container *ngIf="isImageSaved; else elseTemplate">
                        <img [src]="cardImageBase64" />
                    </ng-container>
                    <ng-template #elseTemplate>

                        <img src="./../../assets/placeholder.png" class="img-responsive">
                    </ng-template>

                </div>

            </div>
        </fieldset>
    </div>
    <a class="btn btn-danger" (click)="removeImage()" *ngIf="isImageSaved">Remove</a>
</form>

Nella classe dei componenti

fileChangeEvent(fileInput: any) {
    this.imageError = null;
    if (fileInput.target.files && fileInput.target.files[0]) {
        // Size Filter Bytes
        const max_size = 20971520;
        const allowed_types = ['image/png', 'image/jpeg'];
        const max_height = 15200;
        const max_width = 25600;

        if (fileInput.target.files[0].size > max_size) {
            this.imageError =
                'Maximum size allowed is ' + max_size / 1000 + 'Mb';

            return false;
        }

        if (!_.includes(allowed_types, fileInput.target.files[0].type)) {
            this.imageError = 'Only Images are allowed ( JPG | PNG )';
            return false;
        }
        const reader = new FileReader();
        reader.onload = (e: any) => {
            const image = new Image();
            image.src = e.target.result;
            image.onload = rs => {
                const img_height = rs.currentTarget['height'];
                const img_width = rs.currentTarget['width'];

                console.log(img_height, img_width);


                if (img_height > max_height && img_width > max_width) {
                    this.imageError =
                        'Maximum dimentions allowed ' +
                        max_height +
                        '*' +
                        max_width +
                        'px';
                    return false;
                } else {
                    const imgBase64Path = e.target.result;
                    this.cardImageBase64 = imgBase64Path;
                    this.isImageSaved = true;
                    // this.previewImagePath = imgBase64Path;
                }
            };
        };

        reader.readAsDataURL(fileInput.target.files[0]);
    }
}

removeImage() {
    this.cardImageBase64 = null;
    this.isImageSaved = false;
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.