AngularJS का उपयोग करके फ़ाइल अपलोड करें


296

यहाँ मेरा HTML फॉर्म है:

<form name="myForm" ng-submit="">
    <input ng-model='file' type="file"/>
    <input type="submit" value='Submit'/>
</form>

मैं स्थानीय मशीन से एक छवि अपलोड करना चाहता हूं और अपलोड की गई सामग्री को पढ़ना चाहता हूं। यह सब मैं AngularJS का उपयोग करके करना चाहता हूं।

जब मैं इसके मूल्य को छापने की कोशिश करता हूं तो $scope.fileयह अपरिभाषित होता है।


के बारे में क्या: stackoverflow.com/questions/12979712/…
चेर्निव

जवाबों:


344

यहाँ कुछ उत्तर का उपयोग करने का प्रस्ताव है FormData(), लेकिन दुर्भाग्य से यह एक ब्राउज़र ऑब्जेक्ट है जो इंटरनेट एक्सप्लोरर 9 और नीचे में उपलब्ध नहीं है। यदि आपको उन पुराने ब्राउज़रों का समर्थन करने की आवश्यकता है, तो आपको बैकअप रणनीति का उपयोग करना होगा जैसे कि <iframe>फ्लैश या फ्लैश।

फ़ाइल अपलोडिंग करने के लिए पहले से ही कई Angular.js मॉड्यूल हैं। पुराने ब्राउज़र के लिए इन दोनों का स्पष्ट समर्थन है:

और कुछ अन्य विकल्प:

इनमें से एक को आपकी परियोजना में फिट होना चाहिए, या आपको खुद को कोड करने के तरीके में कुछ अंतर्दृष्टि देनी चाहिए।


4
एक और समाधान (फ़ाइल अपलोड करने के लिए IaaS): github.com/uploadcare/angular-uploadcare
डेविड एवसजनिस्विली

27
एगहेड का इस पर एक अच्छा वीडियो है - egghead.io/lessons/angularjs-file-uploads
एडम ज़ेरनर

2
danialfarid / angular-file-upload का नाम बदलकर ng-file-upload
माइकल

5
3 साल पुराना जवाब। IE 9 2016 में अब DEAD है।
user2404597

5
मुझे लगता है कि आपको लिंक की ओर इशारा करने के बजाय एक उचित समाधान के लिए अपने उत्तर को अपडेट करना चाहिए। यह स्टैक ओवरफ्लो का तरीका है। अन्यथा सिर्फ एक टिप्पणी के रूप में।
एलेक्स रेनॉल्ड्स

178

सबसे आसान HTML5 एपीआई का उपयोग करना है, अर्थात् FileReader

HTML बहुत सीधा है:

<input type="file" id="file" name="file"/>
<button ng-click="add()">Add</button>

अपने नियंत्रक में 'ऐड' विधि को परिभाषित करें:

$scope.add = function() {
    var f = document.getElementById('file').files[0],
        r = new FileReader();

    r.onloadend = function(e) {
      var data = e.target.result;
      //send your binary data via $http or $resource or do anything else with it
    }

    r.readAsBinaryString(f);
}

ब्राउज़र संगतता

डेस्कटॉप ब्राउजर

एज 12, फ़ायरफ़ॉक्स (गेको) 3.6 (1.9.2), क्रोम 7, ओपेरा * 12.02, सफारी 6.0.2

मोबाइल ब्राउजर

फ़ायरफ़ॉक्स (गेको) 32, क्रोम 3, ओपेरा * 11.5, सफारी 6.1

नोट: readAsBinaryString () विधि पदावनत है और इसके बजाय readAsArrayBuffer () का उपयोग किया जाना चाहिए।


10
FileReader मानक HTML5 फ़ाइल API w3.org/TR/FileAPI से एक वर्ग है । यह आपको HTML इनपुट तत्व में निर्दिष्ट फ़ाइल से डेटा पढ़ने और onloadendकॉलबैक फ़ंक्शन के अंदर इसे संसाधित करने की अनुमति देता है । इस API का उपयोग करने के लिए आपको किसी भी लाइब्रेरी की आवश्यकता नहीं है, यह आपके ब्राउज़र में पहले से ही है (जब तक कि आप बहुत पुराना उपयोग न करें)। उम्मीद है की यह मदद करेगा।
यार्गर

15
FileReader.readAsBinaryString को W3C से 12 जुलाई 2012 वर्किंग ड्राफ्ट के रूप में चित्रित किया गया है।
शेन स्टिलवेल

13
आपको कोणीय के साथ DOM का उपयोग नहीं करना चाहिए। बहुत बुरा अभ्यास है।
jeanmatthieud

9
@ सिडरेक्स, नियंत्रक में नहीं है, लेकिन इसे निर्देशन से करना पूरी तरह से बहुत अच्छा है। वास्तव में, यह वही है जो निर्देश के लिए है। आप इसके बारे में Angular docs docs.angularjs.org/guide/directive
yagger

1
@yagger एक विशेष कारण है कि आपके लिंक FileReaderSync का संदर्भ दे रहे हैं readAsArrayBuffer नियमित, Async FileReader API के बजाय विधि (जो केवल वेब कर्मचारियों में उपलब्ध हैं) रहे हैं ?
doldt

58

यह 3 जी पुस्तकालयों के बिना, आधुनिक ब्राउज़र तरीका है। सभी नवीनतम ब्राउज़रों पर काम करता है।

 app.directive('myDirective', function (httpPostFactory) {
    return {
        restrict: 'A',
        scope: true,
        link: function (scope, element, attr) {

            element.bind('change', function () {
                var formData = new FormData();
                formData.append('file', element[0].files[0]);
                httpPostFactory('upload_image.php', formData, function (callback) {
                   // recieve image name to use in a ng-src 
                    console.log(callback);
                });
            });

        }
    };
});

app.factory('httpPostFactory', function ($http) {
    return function (file, data, callback) {
        $http({
            url: file,
            method: "POST",
            data: data,
            headers: {'Content-Type': undefined}
        }).success(function (response) {
            callback(response);
        });
    };
});

HTML:

<input data-my-Directive type="file" name="file">

पीएचपी:

if (isset($_FILES['file']) && $_FILES['file']['error'] == 0) {

// uploads image in the folder images
    $temp = explode(".", $_FILES["file"]["name"]);
    $newfilename = substr(md5(time()), 0, 10) . '.' . end($temp);
    move_uploaded_file($_FILES['file']['tmp_name'], 'images/' . $newfilename);

// give callback to your angular code with the image src name
    echo json_encode($newfilename);
}

js फ़िडल (केवल फ्रंट-एंड) https://jsfiddle.net/vince123/8d18tsey/31/


आप फ़ाइल को नोड में कैसे लाएंगे?
रसदार

कोई और जानकारी? क्या आपको एक ng-submitया प्रपत्र कार्रवाई की आवश्यकता है? यह स्वयं कुछ भी नहीं करता है
एरन

@Emaborsa हैलो मैंने एक jsfiddle को जोड़ा और अधिक पूर्ण php कोड उदाहरण बनाया। यह फ़ाइल इनपुट के मूल्य को बदलने के बाद छवि को जमा कर देता है इसलिए एनजी-सबमिट की आवश्यकता नहीं होती है।
विंस वेरोहेन

एकदम सही सरल समाधान, लेकिन मुझे यह पता लगाने में उम्र लग गई कि डेटा अपलोड करने के लिए मेरी डब्ल्यूसीएफ सेवाओं को कैसे प्राप्त किया जाए। यह महत्वपूर्ण है कि आप डेटा स्ट्रीम लेते हैं, और इसे मल्टीपर्सर की तरह कुछ करके गुजरते हैं, वास्तव में फ़ाइल के डेटा में पढ़ने के लिए: stackoverflow.com/a/23702692/391605 अन्यथा आप कच्चे बाइट्स का भंडारण करेंगे "------ WebKormFormBoundary सामग्री-विवाद: ... आदि .. "
माइक गेल्डहिल

मुझे $ http अनुरोध ऑब्जेक्ट के लिए 'ट्रांसफॉर्मरेंसिएंट: एंगुलर.सिटी' जोड़ने की जरूरत थी क्योंकि मनोय ओझा ने आगे एक लिटले दिखाया, अन्यथा कंटेंट-टाइप ठीक से सेट नहीं होता और उदाहरण काम नहीं करता।
ग्रेगर स्लेव

38

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

http://jsfiddle.net/vishalvasani/4hqVu/

इसमें एक फंक्शन को बुलाया गया

setFiles

व्यू से जो कंट्रोलर में फाइल ऐरे को अपडेट करेगा

या

आप AngularJS का उपयोग करके jQuery फ़ाइल अपलोड की जाँच कर सकते हैं

http://blueimp.github.io/jQuery-File-Upload/angularjs.html


नमस्ते, मैं कुछ के लिए देख रहा था जिसके माध्यम से मैं सिर्फ एक फ़ाइल अपलोड कर सकता हूं और उसके ठीक नीचे प्रदर्शित कर सकता हूं। हालाँकि आपके उदाहरण में मैं ऐसा करने में सक्षम नहीं था। मन नहीं है, लेकिन मैं इस angularjs के लिए नया हूं और इस विशेष उद्देश्य को सरल और मजबूत तरीके से करना सीखना चाहता हूं।
आदित्य सेठी

इससे काफी मदद मिली। धन्यवाद!
राचेल 21

एक अतिरिक्त पुस्तकालय / विस्तार का उपयोग किए बिना उत्कृष्ट उदाहरण। धन्यवाद।
मार्कशीट

4
बहुत उपयोगी है, बस एक नोट .. यह फ़ाइल एपीआई का उपयोग करता है जो IE9 या उससे कम में काम नहीं करता है।
अरजाईन

किसी भी विचार मैं परिणाम से त्रुटियों को कैसे प्राप्त करूं? सर्वर में त्रुटि हो सकती है और मैं उस त्रुटि संदेश को प्रदर्शित करना चाहूंगा ...
CularBytes

17

आप flow.js का उपयोग करके अच्छी फ़ाइल और फ़ोल्डर अपलोड प्राप्त कर सकते हैं ।

https://github.com/flowjs/ng-flow

यहां एक डेमो देखें

http://flowjs.github.io/ng-flow/

यह IE7, IE8, IE9 का समर्थन नहीं करता है, इसलिए आपको अंततः एक संगतता परत का उपयोग करना होगा

https://github.com/flowjs/fusty-flow.js


`flow.js 'शानदार है, लेकिन अभी तक प्रलेखन के खराब है। मुझे एक एकल अपलोड में हेरफेर करने और पूर्वावलोकन जोड़ने और इवेंट बटन को अलग करने की आवश्यकता है, लेकिन मुझे नहीं पता कि यह कैसे करना है।
फ्रांसिस रोड्रिग्स

14

onchangeअपने फ़ंक्शन के लिए इनपुट फ़ाइल तत्व को पास करने के लिए घटना का उपयोग करें ।

<input type="file" onchange="angular.element(this).scope().fileSelected(this)" />

इसलिए जब कोई उपयोगकर्ता किसी फ़ाइल का चयन करता है, तो आपके पास "ऐड" या "अपलोड" बटन पर क्लिक करने की आवश्यकता वाले उपयोगकर्ता के बिना इसका संदर्भ होता है।

$scope.fileSelected = function (element) {
    var myFileSelected = element.files[0];
};

2
यह इच्छानुसार काम नहीं कर रहा है। यह मेरा वर्कफ़्लो है: 1. पृष्ठ को ताज़ा करें 2. नई फ़ाइल जोड़ें। ** पहली फ़ाइल जोड़ी हमेशा अपरिभाषित है। ** 3. एक और फ़ाइल जोड़ें। अब से, अपलोड की गई प्रत्येक फ़ाइल पिछली फ़ाइल है जिसे मैंने जोड़ा था। इसलिए मैं जो दूसरी फ़ाइल जोड़ता हूं, यह पहली फ़ाइल जो मैंने जोड़ी है (जो वास्तव में विफल रही) अपलोड करेगा
पुलकित पाहवा

1
सबसे अच्छी विधि!
Stepan Yakovenko

11

मैंने सभी विकल्पों की कोशिश की जो @Anoyz (सही उत्तर) देता है ... और सबसे अच्छा समाधान https://github.com/danialfarid/angular-file-upload है

कुछ सुविधाएं:

  • प्रगति
  • Multifiles
  • खेत
  • पुराने ब्राउज़र (IE8-9)

यह मेरे लिए ठीक है। आपको बस निर्देशों पर ध्यान देना होगा।

सर्वर-साइड में मैं मल्टीपार्ट अनुरोध को प्रबंधित करने के लिए NodeJs, Express 4 और Multer मिडलवेयर का उपयोग करता हूं।


आप चित्र कैसे दिखाते हैं? बैकएंड से, वे सफलतापूर्वक अंदर जा रहे हैं, लेकिन वे nlzt9LJWRrAZEO3ZteZUOgGc.png प्रारूप के बिना के रूप में सहेजे जा रहे हैं । कैसे जोड़ें?
सरस आर्य

9

एचटीएमएल

<html>
    <head></head>

<body ng-app = "myApp">

  <form ng-controller = "myCtrl">
     <input type = "file" file-model="files" multiple/>
     <button ng-click = "uploadFile()">upload me</button>
     <li ng-repeat="file in files">{{file.name}}</li>
  </form>

स्क्रिप्ट

  <script src = 
     "http://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
  <script>
    angular.module('myApp', []).directive('fileModel', ['$parse', function ($parse) {
        return {
           restrict: 'A',
           link: function(scope, element, attrs) {
              element.bind('change', function(){
              $parse(attrs.fileModel).assign(scope,element[0].files)
                 scope.$apply();
              });
           }
        };
     }]).controller('myCtrl', ['$scope', '$http', function($scope, $http){


       $scope.uploadFile=function(){
       var fd=new FormData();
        console.log($scope.files);
        angular.forEach($scope.files,function(file){
        fd.append('file',file);
        });
       $http.post('http://localhost:1337/mediaobject/upload',fd,
           {
               transformRequest: angular.identity,
               headers: {'Content-Type': undefined}                     
            }).success(function(d)
                {
                    console.log(d);
                })         
       }
     }]);

  </script>


9

<input type=file>तत्व के साथ डिफ़ॉल्ट रूप से काम नहीं करता है एनजी मॉडल के निर्देश । इसे एक कस्टम निर्देश की आवश्यकता है :

1 केselect-ng-files साथ काम करने वाले निर्देशक का कार्य डेमोng-model

angular.module("app",[]);

angular.module("app").directive("selectNgFiles", function() {
  return {
    require: "ngModel",
    link: function postLink(scope,elem,attrs,ngModel) {
      elem.on("change", function(e) {
        var files = elem[0].files;
        ngModel.$setViewValue(files);
      })
    }
  }
});
<script src="//unpkg.com/angular/angular.js"></script>
  <body ng-app="app">
    <h1>AngularJS Input `type=file` Demo</h1>
    
    <input type="file" select-ng-files ng-model="fileList" multiple>
    
    <h2>Files</h2>
    <div ng-repeat="file in fileList">
      {{file.name}}
    </div>
  </body>


$http.postएक FileList से

$scope.upload = function(url, fileList) {
    var config = { headers: { 'Content-Type': undefined },
                   transformResponse: angular.identity
                 };
    var promises = fileList.map(function(file) {
        return $http.post(url, file, config);
    });
    return $q.all(promises);
};

फ़ाइल ऑब्जेक्ट के साथ POST भेजते समय , इसे सेट करना महत्वपूर्ण है 'Content-Type': undefinedएक्सएचआर भेजने विधि तो पता लगा लेगा फ़ाइल वस्तु और स्वचालित रूप से सामग्री प्रकार निर्धारित किया है।


7

एक निर्देश के साथ आसान है

एचटीएमएल:

<input type="file" file-upload multiple/>

जे एस:

app.directive('fileUpload', function () {
return {
    scope: true,        //create a new scope
    link: function (scope, el, attrs) {
        el.bind('change', function (event) {
            var files = event.target.files;
            //iterate files since 'multiple' may be specified on the element
            for (var i = 0;i<files.length;i++) {
                //emit event upward
                scope.$emit("fileSelected", { file: files[i] });
            }                                       
        });
    }
};

निर्देश में हम सुनिश्चित करते हैं कि एक नया स्कोप बनाया गया है और फिर फाइल इनपुट एलिमेंट में किए गए बदलावों को सुनें। जब एक पैरामीटर के रूप में फ़ाइल ऑब्जेक्ट के साथ सभी पूर्वज स्कोप (ऊपर की ओर) की घटना का उत्सर्जन करने के साथ परिवर्तन का पता लगाया जाता है।

आपके नियंत्रक में:

$scope.files = [];

//listen for the file selected event
$scope.$on("fileSelected", function (event, args) {
    $scope.$apply(function () {            
        //add the file object to the scope's files collection
        $scope.files.push(args.file);
    });
});

फिर अपने ऐजैक्स कॉल में:

data: { model: $scope.model, files: $scope.files }

http://shazwazza.com/post/uploading-files-and-json-data-in-the-same-request-with-angular-js/


7

मुझे लगता है कि यह कोणीय फ़ाइल अपलोड है:

एनजी-फ़ाइल-अपलोड

लाइटवेट एंगुलर जेएस फाइलों को अपलोड करने का निर्देश देते हैं।

यहाँ DEMO है पेज है

  • फ़ाइल प्रगति, फ़ाइल खींचें और ड्रॉप (html5), निर्देशिका खींचें और ड्रॉप (वेबकिट), कोर, PUT (html5) / POST विधियों, फ़ाइल प्रकार और आकार की मान्यता, चयनित छवियों का पूर्वावलोकन दिखाने के लिए अपलोड प्रगति, रद्द / गर्भपात का समर्थन करता है। / ऑडियो / वीडियो।
  • क्रॉस पॉलीफ़िल फ़ाइलएपीआई के साथ क्रॉस ब्राउज़र फ़ाइल अपलोड और फाइलरीडर (एचटीएमएल 5 और गैर-एचटीएमएल 5)। फ़ाइल अपलोड करने से पहले क्लाइंट की ओर से सत्यापन / संशोधन की अनुमति देता है
  • Db सेवाओं के लिए सीधे अपलोड CouchDB, imgur, आदि ... Upload.http () का उपयोग करके फ़ाइल की सामग्री प्रकार के साथ। यह कोणीय http POST / PUT अनुरोधों के लिए प्रगति ईवेंट को सक्षम बनाता है।
  • अलग शिम फ़ाइल, फ़ाइलएपीआई फाइलें गैर-एचटीएमएल 5 कोड की मांग पर भरी हुई हैं, जिसका अर्थ है कि आपको केवल एचटीएमएल 5 समर्थन की आवश्यकता नहीं है।
  • लाइटवेट नियमित रूप से $ http का उपयोग करने के लिए अपलोड करें (गैर- HTML5 ब्राउज़रों के लिए शिम के साथ) ताकि सभी कोणीय $ http सुविधाएँ उपलब्ध हों

https://github.com/danialfarid/ng-file-upload


6

आपकी फ़ाइल और json डेटा एक ही समय पर अपलोड हो रहे हैं।

// FIRST SOLUTION
 var _post = function (file, jsonData) {
            $http({
                url: your url,
                method: "POST",
                headers: { 'Content-Type': undefined },
                transformRequest: function (data) {
                    var formData = new FormData();
                    formData.append("model", angular.toJson(data.model));
                    formData.append("file", data.files);
                    return formData;
                },
                data: { model: jsonData, files: file }
            }).then(function (response) {
                ;
            });
        }
// END OF FIRST SOLUTION

// SECOND SOLUTION
// If you can add plural file and  If above code give an error.
// You can try following code
 var _post = function (file, jsonData) {
            $http({
                url: your url,
                method: "POST",
                headers: { 'Content-Type': undefined },
                transformRequest: function (data) {
                    var formData = new FormData();
                    formData.append("model", angular.toJson(data.model));
                for (var i = 0; i < data.files.length; i++) {
                    // add each file to
                    // the form data and iteratively name them
                    formData.append("file" + i, data.files[i]);
                }
                    return formData;
                },
                data: { model: jsonData, files: file }
            }).then(function (response) {
                ;
            });
        }
// END OF SECOND SOLUTION


4

आप एक ऐसी FormDataवस्तु का उपयोग कर सकते हैं जो सुरक्षित और तेज हो:

// Store the file object when input field is changed
$scope.contentChanged = function(event){
    if (!event.files.length)
        return null;

    $scope.content = new FormData();
    $scope.content.append('fileUpload', event.files[0]); 
    $scope.$apply();
}

// Upload the file over HTTP
$scope.upload = function(){
    $http({
        method: 'POST', 
        url: '/remote/url',
        headers: {'Content-Type': undefined },
        data: $scope.content,
    }).success(function(response) {
        // Uploading complete
        console.log('Request finished', response);
    });
}

क्या आप यह भी बता सकते हैं कि 'contentChanged' का उपयोग कहाँ किया गया है?
मार्क जे। श्मिट

जब एक फ़ाइल इनपुट बदल जाता है, तो इस फ़ंक्शंस को ट्रिगर करके अपलोड प्रक्रिया शुरू हो जाएगी।
फ़ारसीड

1
चूंकि वहाँ नहीं है <input type="file" ng-change="contentChanged($event)">, यह कैसे करना है?
मार्क जे। श्मिट

3

http://jsfiddle.net/vishalvasani/4hqVu/ क्रोम और IE में ठीक काम करता है (यदि आप पृष्ठभूमि-छवि में सीएसएस को थोड़ा अपडेट करते हैं)। इसका उपयोग प्रगति बार को अद्यतन करने के लिए किया जाता है:

 scope.progress = Math.round(evt.loaded * 100 / evt.total)

लेकिन फ़ायर्फ़ॉक्स कोणीय के [प्रतिशत] आंकड़ों को DOM में सफलतापूर्वक अपडेट नहीं किया गया है, हालाँकि फाइलें सफलतापूर्वक अपलोड हो रही हैं।


FF के लिए आप loadईवेंट सुन सकते हैं और यदि लंबाई कम्प्यूटेबल है, तो सफल अपलोड को इंगित करने के लिए एक प्रगति ईवेंट को फायर करें। github.com/danialfarid/angular-file-upload पहले से ही उसका ख्याल रखता है।
danial

यह वहाँ है, लेकिन दिए गए फ़िडल में भी इसकी जाँच की जाती है और इसे लागू किया जाता है। फिर भी एफएफ में कोई उम्मीद नहीं।
मयंकपदीक्षित

मुझे लगता है कि अगर आप सिर्फ uploadComplete अंदर uploadProgress फोन यह एफएफ के लिए काम करना चाहिए
danial

नहीं, यह नहीं है, और यहां तक ​​कि अगर यह करता है तो आप क्यों समझा सकते हैं? मैंने अपनी पोस्ट में fiddle का लिंक दिया है। यदि संभव हो तो आप इसे एफएफ में काम करने और समाधान के लिंक पर टिप्पणी करने के लिए अपडेट कर सकते हैं?
मयंकपडिक्सिट

फ़ायरफ़ॉक्स का क्या संस्करण?
डेनियल

3

आप फ़ाइल अपलोड के लिए IaaS पर विचार कर सकते हैं, जैसे कि अपलोडकेयर । इसके लिए एक कोणीय पैकेज है: https://github.com/uploadcare/angular-uploadcare

तकनीकी रूप से इसे एक निर्देश के रूप में लागू किया गया है, जो अपलोड करने के लिए अलग-अलग विकल्प प्रदान करता है, और विजेट के भीतर अपलोड की गई छवियों के लिए जोड़तोड़ करता है:

<uploadcare-widget
  ng-model="object.image.info.uuid"
  data-public-key="YOURKEYHERE"
  data-locale="en"
  data-tabs="file url"
  data-images-only="true"
  data-path-value="true"
  data-preview-step="true"
  data-clearable="true"
  data-multiple="false"
  data-crop="400:200"
  on-upload-complete="onUCUploadComplete(info)"
  on-widget-ready="onUCWidgetReady(widget)"
  value="{{ object.image.info.cdnUrl }}"
 />

अधिक कॉन्फ़िगरेशन विकल्पों के साथ खेलने के लिए: https://uploadcare.com/widget/configure/


3

मुझे पता है कि यह एक देर से प्रवेश है लेकिन मैंने एक सरल अपलोड निर्देश बनाया है। जिसे आप कुछ ही समय में काम कर सकते हैं!

<input type="file" multiple ng-simple-upload web-api-url="/api/Upload" callback-fn="myCallback" />

वेब एपीआई का उपयोग करके जीथब पर एनजी-सिंपल-अपलोड अधिक।


3

एचटीएमएल

<input type="file" id="file" name='file' onchange="angular.element(this).scope().profileimage(this)" />

अपने नियंत्रक में 'प्रोफाइलइमेज ()' विधि जोड़ें

    $scope.profileimage = function(selectimage) {
      console.log(selectimage.files[0]);
 var selectfile=selectimage.files[0];
        r = new FileReader();
        r.onloadend = function (e) {
            debugger;
            var data = e.target.result;

        }
        r.readAsBinaryString(selectfile);
    }

2

यह @ jquery- गुरु के जवाब के लिए एक अद्यतन / टिप्पणी होनी चाहिए, लेकिन जैसा कि मेरे पास पर्याप्त प्रतिनिधि नहीं है, यह यहां जाएगा। यह उन त्रुटियों को ठीक करता है जो अब कोड द्वारा उत्पन्न की जाती हैं।

https://jsfiddle.net/vzhrqotw/

परिवर्तन मूल रूप से है:

FileUploadCtrl.$inject = ['$scope']
function FileUploadCtrl(scope) {

सेवा:

app.controller('FileUploadCtrl', function($scope)
{

यदि वांछित है तो अधिक उपयुक्त स्थान पर जाने के लिए स्वतंत्र महसूस करें।


2

मैंने सभी थ्रेड पढ़े हैं और HTML5 API सॉल्यूशन सबसे अच्छा लगा। लेकिन यह मेरी द्विआधारी फ़ाइलों को बदलता है, उन्हें उन तरीकों से दूषित करता है जिनकी मैंने जांच नहीं की है। समाधान जो मेरे लिए पूरी तरह से काम करता था:

HTML:

<input type="file" id="msds" ng-model="msds" name="msds"/>
<button ng-click="msds_update()">
    Upload
</button>

जे एस:

msds_update = function() {
    var f = document.getElementById('msds').files[0],
        r = new FileReader();
    r.onloadend = function(e) {
        var data = e.target.result;
        console.log(data);
        var fd = new FormData();
        fd.append('file', data);
        fd.append('file_name', f.name);
        $http.post('server_handler.php', fd, {
            transformRequest: angular.identity,
            headers: {'Content-Type': undefined}
        })
        .success(function(){
            console.log('success');
        })
        .error(function(){
            console.log('error');
        });
    };
    r.readAsDataURL(f);
}

सर्वर साइड (PHP):

$file_content = $_POST['file'];
$file_content = substr($file_content,
    strlen('data:text/plain;base64,'));
$file_content = base64_decode($file_content);

1

मैं नीचे कोड का उपयोग करके AngularJS का उपयोग करके फ़ाइलें अपलोड करने में सक्षम हूं:

fileतर्क समारोह के लिए पारित किए जाने की जरूरत है कि के लिए ngUploadFileUploadहै $scope.fileअपने प्रश्न के अनुसार।

यहां मुख्य बिंदु का उपयोग करना है transformRequest: []। यह $ http को फ़ाइल की सामग्री के साथ खिलवाड़ करने से रोकेगा।

       function getFileBuffer(file) {
            var deferred = new $q.defer();
            var reader = new FileReader();
            reader.onloadend = function (e) {
                deferred.resolve(e.target.result);
            }
            reader.onerror = function (e) {
                deferred.reject(e.target.error);
            }

            reader.readAsArrayBuffer(file);
            return deferred.promise;
        }

        function ngUploadFileUpload(endPointUrl, file) {

            var deferred = new $q.defer();
            getFileBuffer(file).then(function (arrayBuffer) {

                $http({
                    method: 'POST',
                    url: endPointUrl,
                    headers: {
                        "accept": "application/json;odata=verbose",
                        'X-RequestDigest': spContext.securityValidation,
                        "content-length": arrayBuffer.byteLength
                    },
                    data: arrayBuffer,
                    transformRequest: []
                }).then(function (data) {
                    deferred.resolve(data);
                }, function (error) {
                    deferred.reject(error);
                    console.error("Error", error)
                });
            }, function (error) {
                console.error("Error", error)
            });

            return deferred.promise;

        }

0

ऊपर स्वीकृत उत्तर ब्राउज़र संगत नहीं है। यदि किसी में संगतता समस्या है, तो यह प्रयास करें।

बेला

कोड देखें

 <div ng-controller="MyCtrl">
      <input type="file" id="file" name="file"/>
      <br>
      <button ng-click="add()">Add</button>
      <p>{{data}}</p>
    </div>

नियंत्रक कोड

var myApp = angular.module('myApp',[]);

function MyCtrl($scope) {
    $scope.data = 'none';    
    $scope.add = function(){
      var f = document.getElementById('file').files[0],
          r = new FileReader();
      r.onloadend = function(e){        
          var binary = "";
var bytes = new Uint8Array(e.target.result);
var length = bytes.byteLength;

for (var i = 0; i < length; i++) 
{
    binary += String.fromCharCode(bytes[i]);
}

$scope.data = (binary).toString();

          alert($scope.data);
      }
      r.readAsArrayBuffer(f);
    }
}

0

सरल शब्दों में

Html में - केवल नीचे दिया गया कोड जोड़ें

     <form name="upload" class="form" data-ng-submit="addFile()">
  <input type="file" name="file" multiple 
 onchange="angular.element(this).scope().uploadedFile(this)" />
 <button type="submit">Upload </button>
</form>

नियंत्रक में - यह फ़ंक्शन तब कहा जाता है जब आप "अपलोड फ़ाइल बटन" पर क्लिक करते हैं। यह फ़ाइल अपलोड करेगा। आप इसे सांत्वना दे सकते हैं।

$scope.uploadedFile = function(element) {
$scope.$apply(function($scope) {
  $scope.files = element.files;         
});
}

नियंत्रकों में और जोड़ें - नीचे कोड फ़ंक्शन में जोड़ें। यह फ़ंक्शन तब कहा जाता है जब आप बटन पर क्लिक करते हैं जो "एपीटी (POST) मार" का उपयोग किया जाता है । यह फ़ाइल (जो अपलोड की गई) और फॉर्म-डेटा को बैकएंड पर भेजेगा।

var url = httpURL + "/reporttojson"
        var files=$scope.files;

         for ( var i = 0; i < files.length; i++)
         {
            var fd = new FormData();
             angular.forEach(files,function(file){
             fd.append('file',file);
             });
             var data ={
              msg : message,
              sub : sub,
              sendMail: sendMail,
              selectUsersAcknowledge:false
             };

             fd.append("data", JSON.stringify(data));
              $http.post(url, fd, {
               withCredentials : false,
               headers : {
                'Content-Type' : undefined
               },
             transformRequest : angular.identity
             }).success(function(data)
             {
                  toastr.success("Notification sent successfully","",{timeOut: 2000});
                  $scope.removereport()
                   $timeout(function() {
                    location.reload();
                }, 1000);

             }).error(function(data)
             {
              toastr.success("Error in Sending Notification","",{timeOut: 2000});
              $scope.removereport()
             });
        }

इस स्थिति में .. मैंने प्रपत्र डेटा के रूप में कोड नीचे जोड़ा

var data ={
          msg : message,
          sub : sub,
          sendMail: sendMail,
          selectUsersAcknowledge:false
         };

0
<form id="csv_file_form" ng-submit="submit_import_csv()" method="POST" enctype="multipart/form-data">
    <input ng-model='file' type="file"/>
    <input type="submit" value='Submit'/>
</form>

कोणीयजेएस नियंत्रक में

$scope.submit_import_csv = function(){

        var formData = new FormData(document.getElementById("csv_file_form"));
        console.log(formData);

        $.ajax({
            url: "import",
            type: 'POST',
            data:  formData,
            mimeType:"multipart/form-data",
            contentType: false,
            cache: false,
            processData:false,
            success: function(result, textStatus, jqXHR)
            {
            console.log(result);
            }
        });

        return false;
    }

0

हमने HTML, CSS और AngularJS का उपयोग किया है। निम्नलिखित उदाहरण से पता चलता है कि AngularJS का उपयोग करके फ़ाइल को कैसे अपलोड किया जाए।

<html>

   <head>
      <script src = "https://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
   </head>

   <body ng-app = "myApp">

      <div ng-controller = "myCtrl">
         <input type = "file" file-model = "myFile"/>
         <button ng-click = "uploadFile()">upload me</button>
      </div>

      <script>
         var myApp = angular.module('myApp', []);

         myApp.directive('fileModel', ['$parse', function ($parse) {
            return {
               restrict: 'A',
               link: function(scope, element, attrs) {
                  var model = $parse(attrs.fileModel);
                  var modelSetter = model.assign;

                  element.bind('change', function(){
                     scope.$apply(function(){
                        modelSetter(scope, element[0].files[0]);
                     });
                  });
               }
            };
         }]);

         myApp.service('fileUpload', ['$http', function ($http) {
            this.uploadFileToUrl = function(file, uploadUrl){
               var fd = new FormData();
               fd.append('file', file);

               $http.post(uploadUrl, fd, {
                  transformRequest: angular.identity,
                  headers: {'Content-Type': undefined}
               })

               .success(function(){
               })

               .error(function(){
               });
            }
         }]);

         myApp.controller('myCtrl', ['$scope', 'fileUpload', function($scope, fileUpload){
            $scope.uploadFile = function(){
               var file = $scope.myFile;

               console.log('file is ' );
               console.dir(file);

               var uploadUrl = "/fileUpload";
               fileUpload.uploadFileToUrl(file, uploadUrl);
            };
         }]);

      </script>

   </body>
</html>

यह TutorialsPoint से आता है , लेकिन कम से कम आपने उनके उदाहरण को सही करने का अच्छा काम किया है, जो स्पष्ट गलतियों के कारण भी नहीं चल सकता है!
बेनिटो

0

सरल निर्देश ( एनजी-फाइल-मॉडल ) का उपयोग करके काम करने का उदाहरण :

.directive("ngFileModel", [function () {
  return {
      $scope: {
          ngFileModel: "="
      },
      link: function ($scope:any, element, attributes) {
          element.bind("change", function (changeEvent:any) {
              var reader = new FileReader();
              reader.onload = function (loadEvent) {
                  $scope.$apply(function () {
                      $scope.ngFileModel = {
                          lastModified: changeEvent.target.files[0].lastModified,
                          lastModifiedDate: changeEvent.target.files[0].lastModifiedDate,
                          name: changeEvent.target.files[0].name,
                          size: changeEvent.target.files[0].size,
                          type: changeEvent.target.files[0].type,
                          data: changeEvent.target.files[0]
                      };
                  });
              }
              reader.readAsDataURL(changeEvent.target.files[0]);
          });
      }
  }
}])

और FormDataअपने फ़ंक्शन में फ़ाइल अपलोड करने के लिए उपयोग करें।

var formData = new FormData();
 formData.append("document", $scope.ngFileModel.data)
 formData.append("user_id", $scope.userId)

सभी क्रेडिट के लिए जाना https://github.com/mistralworks/ng-file-model पर जाते हैं

मैंने एक छोटी सी जांच का सामना किया है आप इसे यहाँ देख सकते हैं: https://github.com/mistralworks/ng-file-model/issues/7

अंत में, यहाँ एक कांटा रेपो है: https://github.com/okasha93/ng-file-model/blob/patch-1/ng-file-model.js


0

कोड फ़ाइल डालने में मदद करेगा

<body ng-app = "myApp">
<form ng-controller="insert_Ctrl"  method="post" action=""  name="myForm" enctype="multipart/form-data" novalidate>
    <div>
        <p><input type="file" ng-model="myFile" class="form-control"  onchange="angular.element(this).scope().uploadedFile(this)">
            <span style="color:red" ng-show="(myForm.myFile.$error.required&&myForm.myFile.$touched)">Select Picture</span>
        </p>
    </div>
    <div>
        <input type="button" name="submit"  ng-click="uploadFile()" class="btn-primary" ng-disabled="myForm.myFile.$invalid" value="insert">
    </div>
</form>
<script src="http://ajax.googleapis.com/ajax/libs/angularjs/1.4.8/angular.min.js"></script> 
<script src="insert.js"></script>
</body>

insert.js

var app = angular.module('myApp',[]);
app.service('uploadFile', ['$http','$window', function ($http,$window) {
    this.uploadFiletoServer = function(file,uploadUrl){
        var fd = new FormData();
        fd.append('file', file);
        $http.post(uploadUrl, fd, {
            transformRequest: angular.identity,
            headers: {'Content-Type': undefined}
        })
        .success(function(data){
            alert("insert successfull");
            $window.location.href = ' ';//your window location
        })
        .error(function(){
            alert("Error");
        });
    }
}]);
app.controller('insert_Ctrl',  ['$scope', 'uploadFile', function($scope, uploadFile){
    $scope.uploadFile = function() {
        $scope.myFile = $scope.files[0];
        var file = $scope.myFile;
        var url = "save_data.php";
        uploadFile.uploadFiletoServer(file,url);
    };
    $scope.uploadedFile = function(element) {
        var reader = new FileReader();
        reader.onload = function(event) {
            $scope.$apply(function($scope) {
                $scope.files = element.files;
                $scope.src = event.target.result  
            });
        }
        reader.readAsDataURL(element.files[0]);
    }
}]);

save_data.php

<?php
    require "dbconnection.php";
    $ext = pathinfo($_FILES['file']['name'],PATHINFO_EXTENSION);
    $image = time().'.'.$ext;
    move_uploaded_file($_FILES["file"]["tmp_name"],"upload/".$image);
    $query="insert into test_table values ('null','$image')";
    mysqli_query($con,$query);
?>

0

यह काम

file.html

<html>
   <head>
      <script src = "https://ajax.googleapis.com/ajax/libs/angularjs/1.3.14/angular.min.js"></script>
   </head>
   <body ng-app = "app">
      <div ng-controller = "myCtrl">
         <input type = "file" file-model = "myFile"/>
         <button ng-click = "uploadFile()">upload me</button>
      </div>
   </body>
   <script src="controller.js"></script>
</html>

controller.js

     var app = angular.module('app', []);

     app.service('fileUpload', ['$http', function ($http) {
        this.uploadFileToUrl = function(file, uploadUrl){
           var fd = new FormData();
           fd.append('file', file);

           $http.post(uploadUrl, fd, {
              transformRequest: angular.identity,
              headers: {'Content-Type': undefined}
           }).success(function(res){
                console.log(res);
           }).error(function(error){
                console.log(error);
           });
        }
     }]);

     app.controller('fileCtrl', ['$scope', 'fileUpload', function($scope, fileUpload){
        $scope.uploadFile = function(){
           var file = $scope.myFile;

           console.log('file is ' );
           console.dir(file);

           var uploadUrl = "/fileUpload.php";  // upload url stands for api endpoint to handle upload to directory
           fileUpload.uploadFileToUrl(file, uploadUrl);
        };
     }]);

  </script>

fileupload.php

  <?php
    $ext = pathinfo($_FILES['file']['name'],PATHINFO_EXTENSION);
    $image = time().'.'.$ext;
    move_uploaded_file($_FILES["file"]["tmp_name"],__DIR__. ' \\'.$image);
  ?>

0

फाइल अपलोड करो

<input type="file" name="resume" onchange="angular.element(this).scope().uploadResume()" ng-model="fileupload" id="resume" />


        $scope.uploadResume = function () { 
            var f = document.getElementById('resume').files[0];
            $scope.selectedResumeName = f.name;
            $scope.selectedResumeType = f.type;
            r = new FileReader();

            r.onloadend = function (e) { 
                $scope.data = e.target.result;
            }

            r.readAsDataURL(f);

        };

फ़ाइलें डाउनलोड करें:

          <a href="{{applicant.resume}}" download> download resume</a>

var app = angular.module("myApp", []);

            app.config(['$compileProvider', function ($compileProvider) {
                $compileProvider.aHrefSanitizationWhitelist(/^\s*(https?|local|data|chrome-extension):/);
                $compileProvider.imgSrcSanitizationWhitelist(/^\s*(https?|local|data|chrome-extension):/);

            }]);

-1
app.directive('ngUpload', function () {   
  return {    
    restrict: 'A',  
    link: function (scope, element, attrs) {

      var options = {};
      options.enableControls = attrs['uploadOptionsEnableControls'];

      // get scope function to execute on successful form upload
      if (attrs['ngUpload']) {

        element.attr("target", "upload_iframe");
        element.attr("method", "post");

        // Append a timestamp field to the url to prevent browser caching results
        element.attr("action", element.attr("action") + "?_t=" + new Date().getTime());

        element.attr("enctype", "multipart/form-data");
        element.attr("encoding", "multipart/form-data");

        // Retrieve the callback function
        var fn = attrs['ngUpload'].split('(')[0];
        var callbackFn = scope.$eval(fn);
        if (callbackFn == null || callbackFn == undefined || !angular.isFunction(callbackFn))
        {
          var message = "The expression on the ngUpload directive does not point to a valid function.";
          // console.error(message);
          throw message + "\n";
        }                      

        // Helper function to create new  i frame for each form submission
        var addNewDisposableIframe = function (submitControl) {
          // create a new iframe
          var iframe = $("<iframe id='upload_iframe' name='upload_iframe' border='0' width='0' height='0' style='width: 0px; height: 0px;
border: none; display: none' />");

          // attach function to load event of the iframe
          iframe.bind('load', function () {

              // get content - requires jQuery
              var content = iframe.contents().find('body').text();

              // execute the upload response function in the active scope
              scope.$apply(function () { callbackFn(content, content !== "" /* upload completed */); });

              // remove iframe
              if (content != "") // Fixes a bug in Google Chrome that dispose the iframe before content is ready.
                setTimeout(function () { iframe.remove(); }, 250);


              submitControl.attr('disabled', null);
              submitControl.attr('title', 'Click to start upload.');
            });

          // add the new iframe to application
          element.parent().append(iframe);
        };

        // 1) get the upload submit control(s) on the form (submitters must be decorated with the 'ng-upload-submit' class)
        // 2) attach a handler to the controls' click event
        $('.upload-submit', element).click(
          function () {

            addNewDisposableIframe($(this) /* pass the submit control */);

            scope.$apply(function () { callbackFn("Please wait...", false /* upload not completed */); });



            var enabled = true;
            if (options.enableControls === null || options.enableControls === undefined || options.enableControls.length >= 0) {
              // disable the submit control on click
              $(this).attr('disabled', 'disabled');
              enabled = false;
            }

            $(this).attr('title', (enabled ? '[ENABLED]: ' : '[DISABLED]: ') + 'Uploading, please wait...');

            // submit the form
            $(element).submit();
          }
        ).attr('title', 'Click to start upload.');
      }
      else
        alert("No callback function found on the ngUpload directive.");     
    }   
  }; 
});



<form class="form form-inline" name="uploadForm" id="uploadForm"
ng-upload="uploadForm12"  action="rest/uploadHelpFile"  method="post"
enctype="multipart/form-data" style="margin-top: 3px;margin-left:
6px"> <button type="submit" id="mbUploadBtn" class="upload-submit"
ng-hide="true"></button> </form>

@RequestMapping(value = "/uploadHelpFile", method =
RequestMethod.POST)   public @ResponseBody String
uploadHelpFile(@RequestParam(value = "file") CommonsMultipartFile[]
file,@RequestParam(value = "fileName") String
fileName,@RequestParam(value = "helpFileType") String
helpFileType,@RequestParam(value = "helpFileName") String
helpFileName) { }

कृपया अपना उत्तर प्रारूपित करें, यह उचित प्रारूप में नहीं है
सांयेश्वर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.