जाओ: सरणी में तारों को पूर्णांक में परिवर्तित करें

Question

मैं किसी सरणी में तारों को एक सरणी में पूर्णांक में कैसे परिवर्तित करूं?

["1", "2", "3"] 

[1, 2, 3] 

को मैं ऑनलाइन कुछ समाधान के लिए खोज की है, लेकिन यह नहीं मिल सका। मैंने सरणी के माध्यम से लूप करने की कोशिश की है और strconv.ParseFloat (v, 64) जहां v मान है लेकिन यह काम नहीं करता है।

Answer 1

आपको वास्तव में स्लाइस के माध्यम से लूप करना होगा। यदि स्लाइस में केवल पूर्णांक होते हैं, तो ParseFloat की कोई आवश्यकता नहीं है, Atoi पर्याप्त है।

import "fmt" 
import "strconv" 

func main() { 
    var t = []string{"1", "2", "3"} 
    var t2 = []int{} 

    for _, i := range t { 
     j, err := strconv.Atoi(i) 
     if err != nil { 
      panic(err) 
     } 
     t2 = append(t2, j) 
    } 
    fmt.Println(t2) 
} 

Playground पर।

Answer 2

उदाहरण के लिए,

package main 

import (
    "fmt" 
    "strconv" 
) 

func sliceAtoi(sa []string) ([]int, error) { 
    si := make([]int, 0, len(sa)) 
    for _, a := range sa { 
     i, err := strconv.Atoi(a) 
     if err != nil { 
      return si, err 
     } 
     si = append(si, i) 
    } 
    return si, nil 
} 

func main() { 
    sa := []string{"1", "2", "3"} 
    si, err := sliceAtoi(sa) 
    if err != nil { 
     fmt.Println(err) 
     return 
    } 
    fmt.Printf("%q %v\n", sa, si) 
} 

आउटपुट:

["1" "2" "3"] [1 2 3] 

खेल का मैदान:

http://play.golang.org/p/QwNO8R_f90

Answer 3

एक टुकड़ा एक सरणी खंड के की जानकारी देता है
यह
0 के होते हैं- सरणी के लिए सूचक,
- खंड की लंबाई, और
- अपनी क्षमता (खंड की अधिकतम लंबाई)

नीचे, स्ट्रिंग सरणी/स्लाइस int करने के लिए सरणी/टुकड़ा बदल जाती है:

package main 

import (
    "fmt" 
    "log" 
    "strconv" 
    "strings" 
) 

func Slice_Atoi(strArr []string) ([]int, error) { 
    // NOTE: Read Arr as Slice as you like 
    var str string       // O 
    var i int        // O 
    var err error       // O 

    iArr := make([]int, 0, len(strArr)) 
    for _, str = range strArr { 
     i, err = strconv.Atoi(str) 
     if err != nil { 
      return nil, err     // O 
     } 
     iArr = append(iArr, i) 
    } 
    return iArr, nil 
} 

func main() { 
    strArr := []string{ 
     "0 0 24 3 15", 
     "0 0 2 5 1 5 11 13", 
    } 

    for i := 0; i < len(strArr); i++ { 
     iArr, err := Slice_Atoi(strings.Split(strArr[i], " ")) 
     if err != nil { 
      log.Print("Slice_Atoi failed: ", err) 
      return 
     } 
     fmt.Println(iArr) 
    } 
} 

आउटपुट:

[0 0 24 3 15] 
[0 0 2 5 1 5 11 13] 

मैं एक परियोजना में इस्तेमाल किया है, तो अन्य उत्तर, ऊपर के लिए // हे के रूप में चिह्नित से एक छोटे से अनुकूलन किया था, भी readabi में थोड़ा तय दूसरों के लिए lity

शुभकामनाएं