कोणीय फ़ाइल अपलोड


190

मैं एंगुलर के साथ शुरुआत कर रहा हूं, मैं जानना चाहता हूं कि एंगुलर 5 फाइल अपलोड भाग कैसे बनाया जाए , मैं किसी भी ट्यूटोरियल या डॉक्टर को खोजने की कोशिश कर रहा हूं, लेकिन मुझे कहीं भी कुछ भी दिखाई नहीं देता है। इसके लिए कोई विचार? और मैंने ng4-files की कोशिश की, लेकिन यह Angular 5 के लिए काम नहीं कर रहा है


2
तो क्या आप ड्रैग एंड ड्रॉप या सिंपल Choose Fileबीटीएन अपलोड करना चाहते हैं? Bdw दोनों मामलों में आप केवल FormData
Dhyey

4
प्राइमेंग पर एक नज़र डालें, मैं इसे थोड़ी देर के लिए इस्तेमाल कर रहा हूं और यह कोणीय v5 के साथ काम करता है। Primefaces.org/primeng/#/fileupload
बुनयामीन कॉस्कुनर

उन लोगों के लिए जिन्हें केवल JSON क्लाइंट को अपलोड करने की आवश्यकता है, इस प्रश्न की जांच करें: stackoverflow.com/questions/54971238/…
AnthonyW

जवाबों:


424

एपीआई के लिए फ़ाइल अपलोड करने के लिए एक कार्य उदाहरण यहां दिया गया है:

चरण 1: HTML टेम्प्लेट (फ़ाइल- upload.component.html)

टाइप के सरल इनपुट टैग को परिभाषित करें file(change)फ़ाइलों को चुनने से निपटने के लिए फ़ंक्शन को जोड़ें ।

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

चरण 2: टाइपस्क्रिप्ट में अपलोड हैंडलिंग (फाइल-अपलोड.कॉमप्लांट)।

चयनित फ़ाइल के लिए एक डिफ़ॉल्ट चर को परिभाषित करें।

fileToUpload: File = null;

वह फ़ंक्शन बनाएं जो आप (change)अपनी फ़ाइल इनपुट टैग के -event में उपयोग करते हैं:

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

यदि आप बहुस्तरीय चयन को संभालना चाहते हैं, तो आप इस फाइल सरणी के माध्यम से पुनरावृति कर सकते हैं।

अब आपको file-upload.service पर कॉल करके फ़ाइल अपलोड फ़ंक्शन बनाएँ:

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

चरण 3: फ़ाइल-अपलोड सेवा (फ़ाइल- upload.service.ts)

POST-method के माध्यम से एक फ़ाइल अपलोड करके, जिसका आपको उपयोग करना चाहिए FormData, क्योंकि आप फ़ाइल को 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));
}

इसलिए, यह बहुत ही सरल काम करने वाला उदाहरण है, जिसे मैं अपने काम में हर रोज इस्तेमाल करता हूं।


6
@ केटी क्या आपने पॉलीफ़िल को सक्षम किया है?
ग्रिगोर डोरसचेंको

2
@GregorDoroschenko मैं फ़ाइल के बारे में अतिरिक्त जानकारी के साथ एक मॉडल का उपयोग करने की कोशिश कर रहा था और मुझे इसे काम करने के लिए प्राप्त करना था: const invFormData: FormData = new FormData(); invFormData.append('invoiceAttachment', invoiceAttachment, invoiceAttachment.name); invFormData.append('invoiceInfo', JSON.stringify(invoiceInfo)); नियंत्रक के दो संगत पैरामीटर हैं, लेकिन मुझे नियंत्रक में JSON को पार्स करना था। मेरा कोर 2 नियंत्रक स्वचालित रूप से पैरामीटर में मॉडल को पिकअप नहीं करेगा। मेरा मूल डिज़ाइन एक फ़ाइल प्रॉपर्टी वाला मॉडल था, लेकिन मैं इसे काम पर नहीं ला सका
पापा स्टाल

1
@GregorDoroschenko मैंने इस कोड की कोशिश कीcreateContrat(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

1
@GregorDoroschenko और मेरे लिए काम नहीं करता है। मैं ws में पोस्ट करता हूं:Content-Disposition: form-data; name="fileKey"; filename="file.docx" Content-Type: application/octet-stream <file>
ओन्नाबी

1
@OnnaB यदि आप फ़ाइल के लिए और अन्य संपत्तियों के लिए फॉर्मडाटा का उपयोग कर रहे हैं, तो आपको अपनी फ़ाइल और अन्य गुणों को फॉर्मडाटा के रूप में पार्स करना चाहिए। आप एक ही समय में फ़ॉर्मडेटा और निकाय का उपयोग नहीं कर सकते हैं।
ग्रेगोर डोरोसेंको

23

इस तरह मैं प्रोजेक्ट में वेब एपीआई पर अपलोड फ़ाइल लागू करता हूं।

मैं किसकी चिंता के लिए साझा करता हूं।

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

क्रमशः

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);
    }
}

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>

एपीआई का उपयोग करने के लिए टीएस फ़ाइल

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

सेवा टीएस

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
आपका रास्ता क्या है हेडर नहीं भेजना?
शालोम दहन

14

बहुत आसान और सबसे तेज़ विधि ng2-file-upload का उपयोग कर रही है

एनपीएम के माध्यम से एनजी 2-फाइल-अपलोड स्थापित करें। npm i ng2-file-upload --save

अपने मॉड्यूल में पहले आयात मॉड्यूल पर।

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

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

मार्कअप:

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

आपके सराहनीय ts में:

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

यह `सबसे सरल उपयोग है। इस की सारी शक्ति जानने के लिए डेमो देखें


4
छवि अपलोड होने पर प्रतिक्रिया कैसे प्राप्त करें? प्रतिक्रिया क्या होगी, प्रलेखन इस भाग को याद कर रहा है।
मुहम्मद शहजाद

7

मैं कोणीय 5.2.11 का उपयोग कर रहा हूं, मुझे ग्रेगर डोरोसेंको द्वारा प्रदान किया गया समाधान पसंद है, हालांकि मैंने देखा कि अपलोड की गई फाइल शून्य बाइट्स की है, मुझे इसे मेरे लिए काम करने के लिए एक छोटा सा बदलाव करना पड़ा।

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));
}

निम्न पंक्तियाँ (फ़ॉर्मडाटा) मेरे लिए कारगर नहीं रहीं।

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

ठीक है, जैसा कि यह धागा Google के पहले परिणामों के बीच दिखाई देता है और अन्य उपयोगकर्ताओं के लिए एक ही सवाल है, तो आपको पहिया को फिर से चालू करने की आवश्यकता नहीं है क्योंकि यह सच है कि एनबी 2-फाइल-अपलोड लाइब्रेरी है जो अपलोड करने की इस प्रक्रिया को सरल बनाता है कोणीय 6 और 7 के साथ फ़ाइल जो आपको करने की आवश्यकता है:

नवीनतम कोणीय सीएलआई स्थापित करें

yarn add global @angular/cli

फिर संगतता की चिंता के लिए आरएक्स-कॉमर्स स्थापित करें

npm install rxjs-compat --save

Ng2-file-upload स्थापित करें

npm install ng2-file-upload --save

अपने मॉड्यूल में FileSelectDirective निर्देश आयात करें।

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

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

अपने घटक में

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

export class AppComponent implements OnInit {

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

खाका

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

बेहतर समझ के लिए आप इस लिंक को देख सकते हैं: एंगुलर 6/7 वाली फाइल कैसे अपलोड करें


1
लिंक के लिए धन्यवाद। डेस्कटॉप पर काम करना अपलोड करना ठीक है, लेकिन मैं अपने जीवन के लिए आईओएस जैसे मोबाइल उपकरणों पर काम करने के लिए अपलोड नहीं कर सकता। मैं कैमरा रोल से एक फ़ाइल का चयन कर सकता हूं लेकिन जब मैं अपलोड करता हूं तो यह हमेशा विफल रहता है। कोई विचार? FYI करें, यह मोबाइल सफारी में चल रहा है, जो इंस्टॉल नहीं किया गया है।
स्कॉट

1
हाय @ScottN और आपका स्वागत है, शायद समस्या आपके द्वारा उपयोग किए जा रहे ब्राउज़र से आई है? क्या आपने इसे दूसरे के साथ टेस्ट किया?
मोहम्मद मक्कौई

1
हाय @ मोहम्मद Makkaoui उत्तर के लिए धन्यवाद। मैंने इसे iOS पर क्रोम में आजमाया और अब भी वही परिणाम है। मैं उत्सुक हूँ अगर यह सर्वर पर पोस्ट करते समय एक हेडर समस्या है? मैं .Net और AWS FYI में लिखे गए एक कस्टम WebAPI का उपयोग कर रहा हूँ।
स्कॉट एन जूल

1
Hi @ScottN हम यह नहीं जान पाएंगे कि क्या यह एक शीर्षलेख समस्या है जब तक कि आप इस लिंक डेवलपर्स का उपयोग करके अपने कोड को डिबग नहीं करते हैं। Googleweb/tools/chrome-devtools/… और देखें कि आपको क्या त्रुटि संदेश मिलता है।
मोहम्मद मक्कौई

6

व्यक्तिगत रूप से मैं फ्रंट-एंड के लिए ngx-material-file-input और बैक-एंड के लिए Firebase का उपयोग कर रहा हूं । क्लाउड फायरस्टार के साथ संयुक्त बैक-एंड के लिए फायरबेस के लिए अधिक सटीक सी लाउड स्टोरेज । एक उदाहरण के नीचे, जो फ़ाइल को 20 एमबी से बड़ा नहीं होने के लिए सीमित करता है, और केवल कुछ फ़ाइल एक्सटेंशन को स्वीकार करता है। मैं अपलोड की गई फ़ाइलों के लिंक को संग्रहीत करने के लिए Cloud Firestore का उपयोग कर रहा हूं , लेकिन आप इसे छोड़ सकते हैं।

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 (आकार सत्यापनकर्ता भाग)

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 (फ़ाइल अपलोडर भाग)

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
बहुत अच्छा लग रहा है, लेकिन आपको toString()contactForm घोषणा की आवश्यकता क्यों है ?
trungk18

1
@ trungk18 इसे एक बार फिर से जांचें, और आप सही हैं कि toString()बेकार है, मेरे जवाब को संपादित किया। जो लोग इस टिप्पणी को पढ़ेंगे, उनके लिए contact.component.ts के अंत fileUploaderमें मैं था । अब यह बस है :। ])].toString()})])]})
डेनियल डेनियलेकी

5
  1. एचटीएमएल

    <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 फ़ाइल
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. बैकएंड स्प्रिंग (जावा फ़ाइल)

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";
    }
}

हमें C ड्राइव में एक फ़ोल्डर "अस्थायी" बनाना होगा, फिर यह कोड कंसोल में Json प्रिंट करेगा और बनाए गए फ़ोल्डर में अपलोड की गई फ़ाइल को बचाएगा।


हम उस फ़ाइल को कैसे पुनः प्राप्त करते हैं? क्या आपके पास उस पर कुछ मार्गदर्शन है?
सिद्धार्थ चौधरी

इसके अलावा मेरा स्प्रिंग सर्वर 8080 पर चल रहा है और कोणीय 3000 पर चल रहा है। अब जब मैं server_url को लोकलहोस्ट के रूप में चिह्नित करता हूं: 8080 / एपीआई / अपलोडफ़ॉर्म कहता है कि कॉर्स की अनुमति नहीं है!
सिद्धार्थ चौधरी

बाइट [] बाइट्स = file.getBytes (); यह बाइट स्ट्रीम देगा। आप इसे फाइल में बदल सकते हैं, कॉर्स की समस्या के लिए आप गूगल में समाधान पा सकते हैं
शफीक मोहम्मद

5

सबसे पहले, आपको अपने कोणीय प्रोजेक्ट में HttpClient सेट करना होगा।

Src / app / app.module.ts फ़ाइल खोलें, HttpClientModule आयात करें और इसे मॉड्यूल के आयात सरणी में जोड़ें:

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 { }

अगला, एक घटक उत्पन्न करें:

$ ng generate component home

इसके बाद, एक अपलोड सेवा बनाएं:

$ ng generate service upload

इसके बाद src / app / upload.service.ts फाइल को निम्न प्रकार से खोलें:

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'  
      });  
   }
}

अगला, src / app / home / home.component.ts फ़ाइल खोलें, और निम्नलिखित आयातों को जोड़कर शुरू करें:

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';

इसके बाद, fileUpload और फाइल चर को परिभाषित करें और UploadService को निम्नानुसार इंजेक्ट करें:

@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) { }

अगला, अपलोड को परिभाषित करें () विधि:

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);  
        }  
      });  
  }

इसके बाद, अपलोडफाइल्स () विधि को परिभाषित करें जिसका उपयोग कई छवि फ़ाइलों को अपलोड करने के लिए किया जा सकता है:

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

अगला, 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();  
}

अगला, हमें अपनी छवि अपलोड यूआई का HTML टेम्पलेट बनाने की आवश्यकता है। Src / app / home / home.component.html फ़ाइल खोलें और निम्नलिखित सामग्री जोड़ें:

       <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>

इस ट्यूटोरियल और इस पोस्ट को देखें


4

कोणीय और नोडज (एक्सप्रेस) का उपयोग करके फ़ाइल अपलोड का पूरा उदाहरण

HTML कोड

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

टीएस घटक कोड

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)
       })
  }

नोड जेएस कोड

fileUpload एपीआई नियंत्रक

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

मुल्टर का उपयोग करके सेवा अपलोड करें

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
httpService कहाँ से आती है?
जेम्स

@James httpService सर्वर को http कॉल करने के लिए कोणीय का http मॉड्यूल है। आप अपनी इच्छानुसार किसी भी http सेवा का उपयोग कर सकते हैं। '' कोणीय / सामान्य / http '' से {HttpClientModule};
रोहित पार्ट

2

इसे इस्तेमाल करे

इंस्टॉल

npm install primeng --save

आयात

import {FileUploadModule} from 'primeng/primeng';

एचटीएमएल

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

1
मैं उपरोक्त उदाहरण का उपयोग करके थक गया। लेकिन मुझे मिल रहा है ।/upload.php नहीं मिला।
संदीप कामथ

2
आपको अपना URL प्रदान करना चाहिए जहां इसे अपलोड के बजाय लोड किया जाना चाहिए। @pandeep kamath
Vignesh

1
@Vignesh आपके उत्तर के लिए धन्यवाद। लेकिन मैंने पाया कि मैं url विशेषता बिल्कुल नहीं देता, क्योंकि यह फ़ाइल को लोड करता है, डिफ़ॉल्ट होना चाहिए।
संदीप कामथ

1
क्या आप बता सकते हैं कि अगर हम इस विधि में कर रहे हैं तो हम php में फाइल कैसे प्राप्त कर सकते हैं।
शेख अरबाज

2

में कोणीय 7/8/9

स्रोत लिंक

यहां छवि विवरण दर्ज करें

बूटस्ट्रैप फॉर्म का उपयोग करना

<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>

में घटक क्लास

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;
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.