ইন্টারফেস থেকে রূপান্তর করুন int

Question 1

আমি একটি জেএসওএন থেকে একটি মান পাওয়ার চেষ্টা করছি এবং এটি ইনট এ কাস্ট করেছি তবে এটি কার্যকর হয় না এবং এটি কীভাবে সঠিকভাবে করতে হয় তা আমি জানি না।

ত্রুটি বার্তাটি এখানে:

...cannot convert val (type interface {}) to type int: need type assertion

এবং কোড:

    var f interface{}
    err = json.Unmarshal([]byte(jsonStr), &f)
    if err != nil {
        utility.CreateErrorResponse(w, "Error: failed to parse JSON data.")
        return
    }

    m := f.(map[string]interface{})

    val, ok := m["area_id"]
    if !ok {
        utility.CreateErrorResponse(w, "Error: Area ID is missing from submitted data.")
        return
    }

    fmt.Fprintf(w, "Type = %v", val)   // <--- Type = float64
    iAreaId := int(val)                // <--- Error on this line.
    testName := "Area_" + iAreaId      // not reaching here

Question 2

পরিবর্তে

iAreaId := int(val)

আপনি একটি টাইপ জোর চান :

iAreaId := val.(int)
iAreaId, ok := val.(int) // Alt. non panicking version

আপনি কেন ইন্টারফেস টাইপ করা মান রূপান্তর করতে পারবেন না তা হল রেফারেন্সড স্পেস অংশগুলিতে এই নিয়মগুলি:

রূপান্তর ফর্ম অভিব্যক্তি T(x)যেখানে Tএকটি টাইপ এবং xএকটি অভিব্যক্তি যে টি টাইপ করতে রূপান্তরিত করা যেতে পারে

...

এই ধরণের যে কোনও একটিতে অ ধ্রুবক মান x টাইপ করে টি তে রূপান্তর করা যায়:

এক্স টি তে নির্ধারিত

এক্স এর টাইপ এবং টি এর অভিন্ন অন্তর্নিহিত প্রকার রয়েছে।

এক্স এর টাইপ এবং টি নামবিহীন পয়েন্টার টাইপ এবং তাদের পয়েন্টার বেস ধরণের অভিন্ন অন্তর্নিহিত প্রকারগুলি রয়েছে।

এক্স এর টাইপ এবং টি উভয় পূর্ণসংখ্যা বা ভাসমান পয়েন্টের ধরণের।

এক্স এর টাইপ এবং টি উভয় জটিল ধরণের।

x একটি পূর্ণসংখ্যা বা বাইট বা রুনের একটি স্লাইস এবং টি একটি স্ট্রিং প্রকার।

এক্স একটি স্ট্রিং এবং টি বাইট বা রুনের স্লাইস।

কিন্তু

iAreaId := int(val)

হয় না মামলা 1. -7 কোন।

Question 3

আমি ধরে নিচ্ছি: আপনি যদি ব্রাউজারের মাধ্যমে জেএসওএন মানটি প্রেরণ করেন তবে আপনি যে কোনও নম্বর প্রেরণ করেছিলেন সেটিই ফ্লোট 64৪ টাইপ হবে যাতে আপনি মানটি গোলাংয়ে সরাসরি পাবেন না।

সুতরাং রূপান্তরটি করুন:

//As that says: 
fmt.Fprintf(w, "Type = %v", val) // <--- Type = float64

var iAreaId int = int(val.(float64))

এইভাবে আপনি যা চেয়েছিলেন তার সঠিক মূল্য পেতে পারেন।

Question 4

ব্যবহার করা হচ্ছে এমন আরও একটি উত্তর যুক্ত করা হচ্ছে switch... আরও বিস্তৃত উদাহরণ রয়েছে। তবে এটি আপনাকে ধারণা দেবে।

উদাহরণস্বরূপ, tপ্রতিটি ক্ষেত্রের মধ্যে নির্দিষ্ট ডেটা টাইপ হয়ে যায় case। নোট, আপনি একটি প্রদান করতে হবে caseএকটি টাইপ কেবলমাত্র একটি টাইপ জন্য, অন্যথায় tএকটি অবশেষ interface।

package main

import "fmt"

func main() {
    var val interface{} // your starting value
    val = 4

    var i int // your final value

    switch t := val.(type) {
    case int:
        fmt.Printf("%d == %T\n", t, t)
        i = t
    case int8:
        fmt.Printf("%d == %T\n", t, t)
        i = int(t) // standardizes across systems
    case int16:
        fmt.Printf("%d == %T\n", t, t)
        i = int(t) // standardizes across systems
    case int32:
        fmt.Printf("%d == %T\n", t, t)
        i = int(t) // standardizes across systems
    case int64:
        fmt.Printf("%d == %T\n", t, t)
        i = int(t) // standardizes across systems
    case bool:
        fmt.Printf("%t == %T\n", t, t)
        // // not covertible unless...
        // if t {
        //  i = 1
        // } else {
        //  i = 0
        // }
    case float32:
        fmt.Printf("%g == %T\n", t, t)
        i = int(t) // standardizes across systems
    case float64:
        fmt.Printf("%f == %T\n", t, t)
        i = int(t) // standardizes across systems
    case uint8:
        fmt.Printf("%d == %T\n", t, t)
        i = int(t) // standardizes across systems
    case uint16:
        fmt.Printf("%d == %T\n", t, t)
        i = int(t) // standardizes across systems
    case uint32:
        fmt.Printf("%d == %T\n", t, t)
        i = int(t) // standardizes across systems
    case uint64:
        fmt.Printf("%d == %T\n", t, t)
        i = int(t) // standardizes across systems
    case string:
        fmt.Printf("%s == %T\n", t, t)
        // gets a little messy...
    default:
        // what is it then?
        fmt.Printf("%v == %T\n", t, t)
    }

    fmt.Printf("i == %d\n", i)
}

Question 5

আমি zzzz এর ধরণের দৃ answer ় উত্তরের সাথে আন্তরিকভাবে একমত এবং অন্যদের চেয়ে আমি দৃ strongly়ভাবে পছন্দ করি। এটি বলেছিল, পছন্দের পদ্ধতিটি কাজ না করার সময় আমাকে কী করতে হয়েছিল তা এখানে ... (ডেটা ক্রস সিরিয়ালাইজেশন সম্পর্কিত দীর্ঘ গল্প)। আপনি এমনকি এটি অনুরূপ প্রকাশের switchসাথে একটি বিবৃতিতে এটি চেইন করতে পারেন case errInt == nil।

package main

import "fmt"
import "strconv"

func main() {
    var v interface{}
    v = "4"

    i, errInt := strconv.ParseInt(v.(string), 10, 64)

    if errInt == nil {
        fmt.Printf("%d is a int", i)
        /* do what you wish with "i" here */
    }
}

আমি উপরে যেমন বলেছি, এইভাবে চেষ্টা করার আগে প্রথমে দৃ type়তার চেষ্টা করুন ।

Question 6

ধরণের রূপান্তরটি আরও ভালভাবে বুঝতে, নীচের কোডটি দেখুন:

package main
import "fmt"
func foo(a interface{}) {
    fmt.Println(a.(int))  // conversion of interface into int
}
func main() {
    var a int = 10
    foo(a)
}

এই কোডটি নিখুঁতভাবে কার্যকর করে এবং ইন্টারফেস টাইপকে প্রকারভেদে রূপান্তর করে

ইন্টারফেস প্রকারের এক্স এক্সপ্রেশন এবং টাইপ টি এর জন্য, প্রাথমিক এক্সপ্রেশন x। (টি) দৃ as়ভাবে বলে যে x শূন্য নয় এবং x এ সঞ্চিত মান টি টাইপের। নোটেশন এক্স। । আরও স্পষ্টভাবে, টি যদি ইন্টারফেস টাইপ না হয়, এক্স। (টি) জোর দিয়েছিল যে গতিশীল প্রকারের x টি টাইপের অনুরূপ। এই ক্ষেত্রে, টি অবশ্যই (ইন্টারফেস) প্রকারের এক্স প্রয়োগ করতে হবে; অন্যথায় প্রকারের অক্ষরটি অবৈধ, যেহেতু এক্সের পক্ষে টি টাইপের মান সংরক্ষণ করা সম্ভব নয় If টি যদি একটি ইন্টারফেস প্রকার, x।

আপনার কোডে ফিরে যাচ্ছেন, এটি

iAreaId := val.(int)

ভাল কাজ করা উচিত। আপনি যদি রূপান্তরকালে ত্রুটি ঘটেছিল তা পরীক্ষা করতে চান, আপনি উপরের লাইনে আবারও লিখতে পারেন

iAreaId, ok := val.(int)

Question 7

আমি একটি লাইব্রেরি লিখেছি যা রূপান্তরগুলি https://github.com/KromDaniel/jonson টাইপ করতে সহায়তা করতে পারে

js := jonson.New([]interface{}{55.6, 70.8, 10.4, 1, "48", "-90"})

js.SliceMap(func(jsn *jonson.JSON, index int) *jonson.JSON {
    jsn.MutateToInt()
    return jsn
}).SliceMap(func(jsn *jonson.JSON, index int) *jonson.JSON {
    if jsn.GetUnsafeInt() > 50{
        jsn.MutateToString()
    }
    return jsn
}) // ["55","70",10,1,48,-90]

Question 8

সবচেয়ে সহজ উপায় আমি এটি করেছি। সেরা উপায় নয় তবে সহজ উপায় আমি জানি।

import "fmt"

func main() {
    fmt.Print(addTwoNumbers(5, 6))
}

func addTwoNumbers(val1 interface{}, val2 interface{}) int {
    op1, _ := val1.(int)
    op2, _ := val2.(int)

    return op1 + op2
}

Question 9

আপনার ইন্টারফেসকে int int ইনট ভ্যালুতে রূপান্তর করার জন্য আপনাকে টাইপ অ্যাসেসারেশন করতে হবে।

iAreaId := val.(int)
iAreaId, ok := val.(int)

আরও তথ্য উপলব্ধ ।

Question 10

আপনার প্রয়োজন হতে পারে

func TransToString(data interface{}) (res string) {
    switch v := data.(type) {
    case float64:
        res = strconv.FormatFloat(data.(float64), 'f', 6, 64)
    case float32:
        res = strconv.FormatFloat(float64(data.(float32)), 'f', 6, 32)
    case int:
        res = strconv.FormatInt(int64(data.(int)), 10)
    case int64:
        res = strconv.FormatInt(data.(int64), 10)
    case uint:
        res = strconv.FormatUint(uint64(data.(uint)), 10)
    case uint64:
        res = strconv.FormatUint(data.(uint64), 10)
    case uint32:
        res = strconv.FormatUint(uint64(data.(uint32)), 10)
    case json.Number:
        res = data.(json.Number).String()
    case string:
        res = data.(string)
    case []byte:
        res = string(v)
    default:
        res = ""
    }
    return
}

Question 11

জেএসএনের সাথে সামঞ্জস্য করার জন্য f কে সঠিক ধরণের বলে ঘোষণা করে সেরা castালাই এড়ানো।