JSON फ़ाइल

Question

से डेटा में पढ़ें यह इस तरह दिखता है मैं एक JSON http://www.randomurl.com/jobs.json पर स्थित फ़ाइल है कहो, मेरे डिकोडर का उपयोग कर उस वेबसाइट से फ़ाइल? मुझे लगता है कि मुझे एचटीपी पैकेज चाहिए लेकिन मुझे नहीं पता कि इसे कैसे लागू किया जाए।

Answer 1

पहला बंद - आपका decoder फ़ंक्शन थोड़ा दूर है। कोई मध्यवर्ती "विशेषताओं का" वस्तु है, तो आप इस के लिए इसे बदल सकते हैं:

decoder : Decoder Job 
decoder = 
    Decode.object3 Job 
    ("task" := Decode.string) 
    ("who" := Decode.string) 
    ("place" := Decode.string) 

आप सही है कि आप elm-http पैकेज की आवश्यकता होगी रहे हैं। इसका उपयोग करके, आप Http.get कार्य बना सकते हैं जो परिणाम को क्रियान्वित करता है।

एक मूल उदाहरण के रूप में, चलिए एक बटन बनाते हैं जो यूआरएल से नौकरियों की सूची खींचता है। HTTP अनुरोध को ट्रिगर करने के लिए हमें GetJobs कार्रवाई की आवश्यकता होगी, और ShowJobs क्रिया जो अनुरोध सफलतापूर्वक लौटाए जाने पर ट्रिगर किया जाएगा।

हमारे कार्रवाई प्रकार मान लिया जाये कि इस तरह दिखता है:

type Action 
    = NoOp 
    | GetJobs 
    | ShowJobs (Maybe Jobs) 

फिर हम एक getJobs समारोह है कि कि चलाया जा सकता है एक काम बनाता है बना सकते हैं। इस सरल उदाहरण के लिए, हम किसी भी HTTP या JSON डिकोडिंग त्रुटियों को दबाने के लिए Task.toMaybe का उपयोग कर सकते हैं।

getJobs : Effects Action 
getJobs = 
    Http.get decoderColl jobsUrl 
    |> Task.toMaybe 
    |> Task.map ShowJobs 
    |> Effects.task 

आदेश यह सब एक साथ गोंद के लिए, हम StartApp इस्तेमाल करेंगे, क्योंकि यह हमें कार्यों और प्रभाव का उपयोग करने देता है। यहां एक कामकाजी उदाहरण दिया गया है कि आप स्थानीय रूप से निर्माण कर सकते हैं, यह मानते हुए कि jobs.json एक ही निर्देशिका में मौजूद है।

import Http 
import StartApp 
import Effects exposing (Effects,Never) 
import Task 
import Html exposing (..) 
import Html.Events exposing (..) 
import Json.Decode as Decode exposing (Decoder, (:=)) 

jobsUrl = "./jobs.json" 

-- StartApp plumbing 
app = 
    StartApp.start { init = init, view = view, update = update, inputs = [] } 

main = 
    app.html 

port tasks : Signal (Task.Task Never()) 
port tasks = 
    app.tasks 


type Action 
    = NoOp 
    | GetJobs 
    | ShowJobs (Maybe Jobs) 

type alias Model = 
    { jobs : Maybe Jobs } 

init = 
    ({ jobs = Nothing }, Effects.none) 

update action model = 
    case action of 
    NoOp -> 
     (model, Effects.none) 
    GetJobs -> 
     ({ model | jobs = Nothing }, getJobs) 
    ShowJobs maybeJobs -> 
     ({ model | jobs = maybeJobs }, Effects.none) 

view address model = 
    div [] 
    [ button [ onClick address GetJobs ] [ text "Click to get jobs!" ] 
    , viewJobs model.jobs 
    ] 

viewJobs maybeJobs = 
    let 
    viewJob job = 
     li [] [ text ("Task: " ++ job.task ++ "; Who: " ++ job.who ++ "; Place: " ++ job.place) ] 
    in 
    case maybeJobs of 
     Nothing -> 
     div [] [ text "No jobs to display. Try clicking the button" ] 
     Just jobs -> 
     ul [] (List.map viewJob jobs) 

-- This is the key to map the result of the HTTP GET to an Action 
-- Note: Task.toMaybe swallows any HTTP or JSON decoding errors 
getJobs : Effects Action 
getJobs = 
    Http.get decoderColl jobsUrl 
    |> Task.toMaybe 
    |> Task.map ShowJobs 
    |> Effects.task 

-- An alternative to Task.toMaybe which dumps error information to the console log 
toMaybeWithLogging : Task.Task x a -> Task.Task y (Maybe a) 
toMaybeWithLogging task = 
    Task.map Just task `Task.onError` (\msg -> Debug.log (toString msg) (Task.succeed Nothing)) 

-- The Job type aliases from the question 
type alias Job = { 
    task : String 
    , who : String 
    , place: String 
} 

type alias Jobs = List Job 

-- The updated Job decoder 
decoder : Decoder Job 
decoder = 
    Decode.object3 Job 
    ("task" := Decode.string) 
    ("who" := Decode.string) 
    ("place" := Decode.string) 

decoderColl : Decoder Jobs 
decoderColl = 
    Decode.object1 identity 
    ("jobs" := Decode.list decoder)