प्रकार, आदि

Question

कृपया इस टाइप करें।

scala> 86400000 * 150 
res0: Int = 75098112 


scala> val i : Long = 86400000 * 150 
i: Long = 75098112 


val i = 86400000 * 150.asInstanceOf[Long] 
i: Long = 12960000000 

val i = 86400000 * 150L 
i: Long = 12960000000 

क्या दुनिया में यहाँ चल रहा है? मैं स्काइडाइविंग कर रहा हूं और मुझे कहना होगा कि यह सबसे खतरनाक चीज है जिसे मैंने कभी देखा है। इसके लिए कोई कंपाइलर जांच नहीं है? जाहिर है अगर मैं एक चर के लिए 150 प्रतिस्थापित कर रहा था जो अलग है।

* संपादित करें *

यह वास्तविक कोड है कि मुझे चिंतित हो गया था।

val oneDay = 86400000 
val days150 = oneDay * 150 

days150 = 75098112 

यह स्कैला की गलती या किसी के अलावा गलती नहीं थी। बस मुझे चिंतित हो गया।

Answer 1

इस बारे में स्कैला-विशिष्ट कुछ भी नहीं है। यह केवल उस प्रकार के अप्रासंगिक होने के असाइनमेंट के लक्ष्य प्रकार का मामला है जिसमें एक ऑपरेशन (इस मामले में गुणा) किया जाता है।

उदाहरण के लिए, सी # में:

using System; 

class Program 
{ 
    static void Main(string[] args) 
    { 
     int a = unchecked(86400000 * 150); 
     long b = unchecked(86400000 * 150); 
     long c = 86400000 * (long) 150; 
     long d = 86400000 * 150L; 
     Console.WriteLine(a); // 75098112 
     Console.WriteLine(b); // 75098112 
     Console.WriteLine(c); // 12960000000 
     Console.WriteLine(d); // 12960000000 
    } 
} 

क्योंकि सी # संकलक बहुत चालाक एहसास है कि आपरेशन अतिप्रवाह, लेकिन केवल क्योंकि दोनों ऑपरेंड स्थिरांक हैं है unchecked भाग यहाँ है। यदि ऑपरेंड एक वैरिएबल था, तो यह unchecked के बिना ठीक होगा।

जावा में इसी तरह

:

public class Program 
{ 
    public static void main(String[] args) 
    { 
     int a = 86400000 * 150; 
     long b = 86400000 * 150; 
     long c = 86400000 * (long) 150; 
     long d = 86400000 * 150L; 
     System.out.println(a); // 75098112 
     System.out.println(b); // 75098112 
     System.out.println(c); // 12960000000 
     System.out.println(d); // 12960000000 
    } 
} 

Answer 2

यह कोई अंतर्निहित कास्टिंग चल रहा है स्पष्ट है। 86400000 * 150 को int * int के रूप में देखा जाता है, मैं जेवीएम की कल्पना करता हूं। इसकी गणना तब की जाती है जब आप जो भी वैरिएबल टाइप चाहते हैं उसे कोई फर्क नहीं पड़ता। तो करने के लिए सही चीज यह सुनिश्चित करती है कि कम से कम संख्या में से एक या चर को लंबे प्रकार के रूप में डाला जाए, 86400000 * 150.toLong। जेवीएम बड़े प्रकार के लिए डिफ़ॉल्ट रूप से प्रतीत होता है।

बीटीडब्ल्यू, मेरा मानना ​​है कि स्कैला के अंत में ओवरफ्लो चेक केवल प्रदर्शन को अपंग करेगा। तो स्वचालित प्रकार के रूपांतरण की चूक जोखिम को पेश करती है लेकिन बेहतर प्रदर्शन की अनुमति देती है। आपको बस सावधान रहना होगा ..., यदि आप सी/सी ++ बैकअप से आते हैं तो दूसरी प्रकृति होनी चाहिए।