"++" এবং "-" অপারেটরদের এক্সকোড 7.3 ব্যবহার করা হয়েছে

139

আমি এক্সকোড 7.3 নোটটি দেখছি এবং আমি এই সমস্যাটি লক্ষ্য করছি।

++ এবং - অপারেটরগুলি হ্রাস করা হয়েছে

কেউ কেউ ব্যাখ্যা করতে পারে কেন এটি হ্রাস করা হয়? আর আমি ডান Xcode এর নতুন সংস্করণে এখন আপনি পরিবর্তে ব্যবহার করা যাচ্ছে যে ++এই x += 1;

উদাহরণ:

for var index = 0; index < 3; index += 1 {
    print("index is \(index)")
}

— ওলেগ গর্দিচুক
সূত্র

6

আমি মনে করি এই প্রশ্নটি যদি স্ট্যাকওভারফ্লোয়ের বাইরে না যায় তবে মূলত গিথুবটিতে দ্রুত বিবর্তনের জন্য গৃহীত সমস্ত প্রস্তাব পাওয়া যায়, আপনি এই প্রস্তাবটির কারণ সম্পর্কে আরও জানতে পারেন github.com/apple/swift-evolution/blob/master / প্রস্তাবসমূহ /…

— ভিক্টর সিগলার

7

আমি গুরুত্ব সহকারে কেবল উদ্দেশ্য-সি-তে ফিরে যাওয়ার বিষয়টি বিবেচনা করছি। সুইফটে সমস্ত পরিবর্তন চালিয়ে যাওয়ার চেষ্টা করার মতো নয়।

— গ্রেগ ব্রাউন

3

@OlegGordiichuk এটা জিনিসের জন্য-লুপ সি-স্টাইল খুব অপসারণ করা হবে যে, এই দেখুন github.com/Vkt0r/swift-evolution/blob/master/proposals/... না তাই আপনার যা দরকার আরো ব্যবহার করবেন ++এবং --অপারেটরদের

— ভিক্টর সিগলার

10

আমার স্বাদ জন্য অনেক ব্রেকিং পরিবর্তন আছে। আমি সমস্তই সংস্কারের জন্য, তবে আমি যখনই একটি কোডকোড পয়েন্ট প্রকাশ করি তখনই আমার কোডবেসের উল্লেখযোগ্য অংশগুলি পুনরায় লেখাতে আমার সময় ব্যয় করতে চাই না।

— গ্রেগ ব্রাউন

4

@ ফগমিস্টার আমি নিশ্চিত না যে আমি কীভাবে আরও পরিষ্কার হতে পারি। আমি সুইফ্ট ব্যবহার করতে পছন্দ করব তবে এটি যথেষ্ট স্থিতিশীল বলে আমি মনে করি না। আমি অতীতে অন্যান্য ভাষাগুলির সাথে ব্যাপকভাবে কাজ করেছি এবং এত অল্প সময়ের মধ্যে এতগুলি ব্রেকিং পরিবর্তন কখনও ঘটেনি। আমি মনে করি অ্যাপল আমাদের সবাইকে সুইফ্ট গ্রহণ করতে চায় তবে তারা এটিকে যা করা উচিত তার থেকে আরও কঠিন করে তুলছে।

— গ্রেগ ব্রাউন

210

সুইফটের নির্মাতা ক্রিস ল্যাটনার থেকে এখানে একটি সম্পূর্ণ ব্যাখ্যা । আমি পয়েন্টগুলি সংক্ষেপে বলব:

এটি সুইচ শিখার সময় আপনাকে অন্য একটি ফাংশন শিখতে হবে
এর চেয়ে বেশি খাটো নয় x += 1
সুইফট সি হয় না কেবল সি প্রোগ্রামারদের খুশি করার জন্য সেগুলি ওপরে বহন করা উচিত নয়
লুপের জন্য এর মূল ব্যবহারটি সি-স্টাইলে রয়েছে: for i = 0; i < n; i++ { ... }যা সুইফ্টের আরও ভাল বিকল্প রয়েছে, যেমন for i in 0..<n { ... }(লুপের জন্য সি-স্টাইলটিও চলে যাচ্ছে )
পড়তে এবং বজায় রাখতে জটিল হতে পারে, উদাহরণস্বরূপ, এর মান কী x - ++xবা foo(++x, x++)?
ক্রিস ল্যাটনার এটি পছন্দ করেন না।

আগ্রহী (এবং লিঙ্ক পচা এড়ানোর জন্য) জন্য, ল্যাটনার তার নিজের কথায় কারণগুলি:

এই অপারেটরগুলি প্রথম প্রোগ্রামিং ভাষা হিসাবে সুইফটটি শিখতে বোঝা বাড়িয়ে দেয় - বা অন্য কোনও ক্ষেত্রে যেখানে আপনি ইতিমধ্যে অন্য ভাষা থেকে এই অপারেটরগুলি জানেন না।

তাদের অভিব্যক্তিগত সুবিধাটি ন্যূনতম - x ++ x + = 1 এর চেয়ে খুব কম নয়।

সুইফটি ইতিমধ্যে সি থেকে বিচ্যুত হয়েছে যে =, + = এবং অন্যান্য অ্যাসাইনমেন্ট-এর মতো ক্রিয়াকলাপ শূন্য হয়ে যায় (বেশ কয়েকটি কারণে)। এই অপারেটররা সেই মডেলের সাথে বেমানান।

সুইফ্টের শক্তিশালী বৈশিষ্ট্য রয়েছে যা আপনি অন্যান্য ভাষায় লুপের জন্য সি-স্টাইলে ++ i ব্যবহার করতে চান এমন প্রচলিত সাধারণ কারণগুলিকে সরিয়ে দেয়, সুতরাং এগুলি তুলনামূলকভাবে সুনির্দিষ্টভাবে লিখিত সুইফট কোডে ব্যবহৃত হয়। এই বৈশিষ্ট্যগুলির মধ্যে অন্তর্ভুক্ত লুপ, ব্যাপ্তি, গণনা, মানচিত্র ইত্যাদি অন্তর্ভুক্ত রয়েছে include

এই অপারেটরগুলির ফলাফলের মানটি ব্যবহার করে এমন কোডটি প্রায়শই বিভ্রান্তিকর এবং কোডের একজন পাঠক / রক্ষণাবেক্ষণকারীকে সূক্ষ্ম করে। তারা "অত্যধিক কৌতূহলপূর্ণ" কোডটি উত্সাহ দেয় যা সুন্দর হতে পারে তবে বুঝতে অসুবিধা হয়।

যদিও সুইফ্ট মূল্যায়নের ক্রমকে সংজ্ঞায়িত করেছে, যে কোনও কোড যা এর উপর নির্ভর করে (যেমন foo (++ a, a ++)) এটি ভালভাবে সংজ্ঞায়িত করা হলেও অনাকাঙ্ক্ষিত হবে।

এই অপারেটরগুলি অপেক্ষাকৃত কয়েকটি ধরণের ক্ষেত্রে প্রযোজ্য: পূর্ণসংখ্যা এবং ভাসমান পয়েন্ট স্কেলার এবং পুনরাবৃত্ত-মত ধারণা। এগুলি জটিল সংখ্যা, ম্যাট্রিকেস ইত্যাদিতে প্রয়োগ হয় না

অবশেষে, এগুলি "যদি আমাদের ইতিমধ্যে এটি না থাকে, তবে আমরা কী সেগুলি সুইফ্ট 3-এ যুক্ত করব?" এর মেট্রিকটিতে ব্যর্থ?

— কোড ভিন্ন
সূত্র

54

আমার কথা, আসল উত্তরটি number নম্বর That এটি ঠিক আছে, আমরা (প্রাক্তন সি, জাভা, ... প্রোগ্রামারস) যথেষ্ট নমনীয় :-)। সাধারণত, বাস্তব বিশ্বের জন্য, রূপান্তরকরণ, ক্রসওভার এবং নির্বাচন যথেষ্ট। আমি, আপনি এবং

— ক্রিসও

5

পঞ্চম পয়েন্ট: এগুলি সর্বদা সি-এ বাস্তবায়ন নির্ভর ছিল এবং তাদের কোনও বোধগম্য কখনও করেনি। কেবল আচরণটি সংজ্ঞায়িত করুন এবং আমরা এটিতে অভ্যস্ত হয়ে যাব। কোনও বাস্তব কারণ ছাড়াই ফিরে যেতে এবং পুরোপুরি ভাল পুরানো কোডটি পরিবর্তন করা ভাল।

— এচেলন

3

আমি ৩ পয়েন্টটি পছন্দ করি আপনাকে চিরকালের জন্য উত্তরাধিকারের চুক্তিতে ফেলে দেওয়া যাবে না। আমি সি পছন্দ করি তবে আপনি একটি নতুন প্রোগ্রামিং ভাষা তৈরি করছেন; স্লেটটিকে যতটা পরিষ্কার করা দরকার ততই পরিষ্কার হওয়া শুরু করুন।

— নিকোলাস মিয়ারি

8

এটি আপেল পছন্দ করে যাতে তারা তাদের মতো করে ভাবতে বাধ্য করে। আমি মনে করি এটি পুরোপুরি সূক্ষ্ম এবং আপনার পরিবর্তনশীল বৃদ্ধি বা ডিক্রিভেন্ট করার জন্য যে কোনও জায়গায় ব্যবহার করা উচিত। এটি আপনাকে "শিখতে হবে" এমন কিছু নয় যা আপনি এটি না করেই ভাল করবেন। এবং # 5 হ'ল খারাপ লেখা লিখিত কোড, এর মতো পছন্দগুলি আমি কখনই দেখিনি। সুতরাং # 6 এটি। এটি বর্ণনা করা আমাকে আমার মাথা আঁচড়ান এবং একটি গুগল অনুসন্ধান করতে যথেষ্ট, তাই ক্রিসকে আমার সময় নষ্ট করার জন্য ধন্যবাদ।

— csga5000

4

@ csga5000 এটি একটি দুর্বল যুক্তি বিবেচনা করে যে আপনি যদি চান সত্যিই আপনি কেবল অপারেটরটিকে নিজেরাই সংজ্ঞায়িত করতে পারেন। লোকেদের মতো ভাবতে চাইলে অ্যাপলের সাথে এর কোনও যোগসূত্র নেই। এটি কেবল ভাষার সাথে খাপ খায় না। যদি ++সি-শৈলী ভাষায় উপস্থিত করেনি, তাদের অধিকার মনে কোন এক সুইফট 3.0 নকশা তাকান এবং মনে করে যে একটি হবে ++অপারেটর এটি একটি চমৎকার ছাড়াও হতে হবে।

— ওভাররেেক্টর

37

আমি বুঝতে পারি যে এই মন্তব্যটি প্রশ্নের জবাব দেয় না তবুও এই অপারেটরদের কীভাবে কাজ করা যায় এবং কীভাবে এই জাতীয় সমাধানটি নীচে পাওয়া যেতে পারে এমন কোনও সমাধানের সন্ধান করতে পারে এমন লোকেরা থাকতে পারে। 😇

আমি ব্যক্তিগতভাবে পছন্দ ++এবং --অপারেটর। এগুলি কার্যকর নয় যে তারা পরিচালনা করা কঠিন বা এই মতামতের সাথে আমি একমত হতে পারি না। এই অপারেটরগুলি কী করে বিকাশকারীরা বুঝতে পারে (এবং আমরা বেশ সাধারণ জিনিস নিয়ে কথা বলছি) কোডটি খুব পরিষ্কার হওয়া উচিত।

অপারেটরদের কেন অবহেলা করা হয়েছিল তার ব্যাখ্যায় উল্লেখ করা হয়েছে যে লুপগুলির জন্য তাদের মূল ব্যবহার সি-স্টাইলে ছিল। আমি অন্যদের সম্পর্কে জানি না কিন্তু আমি ব্যক্তিগতভাবে সব সময়ে সি-শৈলী loops ব্যবহার করে না এবং এখনও আছে অনেক অন্যান্য স্থান বা পরিস্থিতিতে যখন ++বা --অপারেটর দরকারী।

আমিও যে উল্লেখ করতে চাই varName++আয় একটি মান, তাই এটি ব্যবহার করা যেতে পারে returnযেহেতু varName += 1করতে পারেন না।

আপনারা যারা এই অপারেটরদের এখানে কাজ করতে চান তার সমাধান হ'ল:

prefix operator ++ {}
postfix operator ++ {}

prefix operator -- {}
postfix operator -- {}


// Increment
prefix func ++(inout x: Int) -> Int {
    x += 1
    return x
}

postfix func ++(inout x: Int) -> Int {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: UInt) -> UInt {
    x += 1
    return x
}

postfix func ++(inout x: UInt) -> UInt {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Int8) -> Int8 {
    x += 1
    return x
}

postfix func ++(inout x: Int8) -> Int8 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: UInt8) -> UInt8 {
    x += 1
    return x
}

postfix func ++(inout x: UInt8) -> UInt8 {
    x += 1
    return (x - 1)
}
prefix func ++(inout x: Int16) -> Int16 {
    x += 1
    return x
}

postfix func ++(inout x: Int16) -> Int16 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: UInt16) -> UInt16 {
    x += 1
    return x
}

postfix func ++(inout x: UInt16) -> UInt16 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Int32) -> Int32 {
    x += 1
    return x
}

postfix func ++(inout x: Int32) -> Int32 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: UInt32) -> UInt32 {
    x += 1
    return x
}

postfix func ++(inout x: UInt32) -> UInt32 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Int64) -> Int64 {
    x += 1
    return x
}

postfix func ++(inout x: Int64) -> Int64 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: UInt64) -> UInt64 {
    x += 1
    return x
}

postfix func ++(inout x: UInt64) -> UInt64 {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Double) -> Double {
    x += 1
    return x
}

postfix func ++(inout x: Double) -> Double {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Float) -> Float {
    x += 1
    return x
}

postfix func ++(inout x: Float) -> Float {
    x += 1
    return (x - 1)
}

prefix func ++(inout x: Float80) -> Float80 {
    x += 1
    return x
}

postfix func ++(inout x: Float80) -> Float80 {
    x += 1
    return (x - 1)
}

prefix func ++<T : _Incrementable>(inout i: T) -> T {
    i = i.successor()
    return i
}

postfix func ++<T : _Incrementable>(inout i: T) -> T {
    let y = i
    i = i.successor()
    return y
}

// Decrement
prefix func --(inout x: Int) -> Int {
    x -= 1
    return x
}

postfix func --(inout x: Int) -> Int {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: UInt) -> UInt {
    x -= 1
    return x
}

postfix func --(inout x: UInt) -> UInt {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Int8) -> Int8 {
    x -= 1
    return x
}

postfix func --(inout x: Int8) -> Int8 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: UInt8) -> UInt8 {
    x -= 1
    return x
}

postfix func --(inout x: UInt8) -> UInt8 {
    x -= 1
    return (x + 1)
}
prefix func --(inout x: Int16) -> Int16 {
    x -= 1
    return x
}

postfix func --(inout x: Int16) -> Int16 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: UInt16) -> UInt16 {
    x -= 1
    return x
}

postfix func --(inout x: UInt16) -> UInt16 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Int32) -> Int32 {
    x -= 1
    return x
}

postfix func --(inout x: Int32) -> Int32 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: UInt32) -> UInt32 {
    x -= 1
    return x
}

postfix func --(inout x: UInt32) -> UInt32 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Int64) -> Int64 {
    x -= 1
    return x
}

postfix func --(inout x: Int64) -> Int64 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: UInt64) -> UInt64 {
    x -= 1
    return x
}

postfix func --(inout x: UInt64) -> UInt64 {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Double) -> Double {
    x -= 1
    return x
}

postfix func --(inout x: Double) -> Double {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Float) -> Float {
    x -= 1
    return x
}

postfix func --(inout x: Float) -> Float {
    x -= 1
    return (x + 1)
}

prefix func --(inout x: Float80) -> Float80 {
    x -= 1
    return x
}

postfix func --(inout x: Float80) -> Float80 {
    x -= 1
    return (x + 1)
}

prefix func --<T : BidirectionalIndexType>(inout i: T) -> T {
    i = i.predecessor()
    return i
}

postfix func --<T : BidirectionalIndexType>(inout i: T) -> T {
    let y = i
    i = i.predecessor()
    return y
}

— 0101
সূত্র

return (x - 1)পোস্টফিক্স অপারেটরদের জন্য আমি আপনার পছন্দ করি না - আইএমএইচও এর ক্লান্তিকর শব্দার্থকগুলি বজায় রাখা পরিষ্কার করে যে তারা যেটি দেবে তার চেয়ে মূল মূল্য ফেরত দেয় (এর একটি অনুলিপি)x + 1 - 1

— অ্যালনিতাক

আমি এটি পছন্দ করি না তবে এটি করার কোনও অন্য উপায় (ভাল, ক্লিনার) সম্পর্কে আমি জানি না। আমি আপনার দ্বিতীয় বিষয়টি পুরোপুরি বুঝতে পারি না।

— 0101

1

আমি দেখতে পাচ্ছি, আমি কেবল অন্য ভেরিয়েবল তৈরি করার স্বার্থে এটি করতে চাইনি (বা বরং এই ক্ষেত্রে স্থির)। যদি আমরা Intকেবল সে সম্পর্কে কথা বলি তবে ফলাফলটি (x + 1)ওভারফ্লো হয়ে যাবে যা কার্যকরভাবে বাধা দেবে এবং তাই এটিও চালানো result - 1হবে না। Doubleউদাহরণস্বরূপ অন্যান্য ডেটাটাইপগুলি যদিও অন্যভাবে আচরণ করে তাই আমার এটি তদন্ত করা দরকার।

— 0101

3

আপনি এটির deferজন্যও ব্যবহার করতে পারেন । defer { x += 1 }; return x

— টিম ভার্মিউলেন

4

জেনারিকগুলি ব্যবহার করে এবং কয়েকটি লাইনে এটি লিখবেন না কেন?

— λαβέ.λαβέ

22

অ্যাপল অপসারণ করেছে ++ এবং অন্য একটি প্রাচীন traditionalতিহ্যবাহী উপায়ে এটি আরও সহজ করে তুলেছে।

পরিবর্তে ++, আপনার লিখতে হবে +=।

উদাহরণ:

var x = 1

//Increment
x += 1 //Means x = x + 1

একইভাবে হ্রাস অপারেটরের জন্য --, আপনাকে লিখতে হবে-=

উদাহরণ:

var x = 1

//Decrement
x -= 1 //Means x = x - 1

জন্য forলুপ:

বর্ধনের উদাহরণ:

পরিবর্তে

for var index = 0; index < 3; index ++ {
    print("index is \(index)")
}

তুমি লিখতে পারো:

//Example 1
for index in 0..<3 {
    print("index is \(index)")
}

//Example 2
for index in 0..<someArray.count {
    print("index is \(index)")
}

//Example 3
for index in 0...(someArray.count - 1) {
    print("index is \(index)")
}

হ্রাস উদাহরণ:

for var index = 3; index >= 0; --index {
   print(index)
}

তুমি লিখতে পারো:

for index in 3.stride(to: 1, by: -1) {
   print(index)
}
//prints 3, 2

for index in 3.stride(through: 1, by: -1) {
   print(index)
}
//prints 3, 2, 1

for index in (0 ..< 3).reverse() {
   print(index)
}

for index in (0 ... 3).reverse() {
   print(index)
}

আশাকরি এটা সাহায্য করবে!

— সোহিল আর মেমন
সূত্র

তারা কিছুই প্রতিস্থাপন করেনি; +=সেখানে সব ছিল।

— নিকোলাস মিয়ারি

@ নিকোলাসমিয়ারি হ্যাঁ কেবল আরও ভাল ফর্ম্যাট দিয়ে সম্পাদনা করা হচ্ছে

— সোহিল আর মেমন

@ নিকোলাসমিয়ারি আপনি এখন চেক করতে পারেন?

— সোহিল আর মেমন

3

কি ++iএবং --i?

— Zigii Wong

7

ক্রিস ল্যাটনার ++ এবং - এর বিরুদ্ধে যুদ্ধে নেমেছেন। তিনি লিখেছেন, “কোড যা এই অপারেটরগুলির ফলাফলের মানটি ব্যবহার করে তা প্রায়শই বিভ্রান্তিকর এবং কোডের একজন পাঠক / রক্ষণাবেক্ষণকারীকে সূক্ষ্ম করে। তারা "অত্যধিক কৌতুকপূর্ণ" কোডটি উত্সাহিত করে যা সুন্দর হতে পারে তবে এটি বুঝতে অসুবিধা… .সেইল সুইফ্ট মূল্যায়নের যথাযথ সংজ্ঞা প্রদান করেছে, কোনও কোড যা এর উপর নির্ভর করে (যেমন ফু (++ এ, একটি ++)) এটি অনাকাঙ্ক্ষিত হবে সুস্পষ্টভাবে সংজ্ঞায়িত করা হয়েছিল… এগুলি মেট্রিককে ব্যর্থ করে "যদি আমাদের ইতিমধ্যে এটি না থাকে, তবে আমরা কী তাদের সুইফট 3 এ যুক্ত করব?" "

অ্যাপল দ্রুত, একটি পরিষ্কার, পরিষ্কার, অ-বিভ্রান্তিকর এবং সোজা-থেকে-দ্য-পয়েন্টের ভাষাটি রাখতে চেয়েছিল। এবং তাই তারা ++ এবং - কীওয়ার্ড অবহেলা করেছে।

— জে মেহতা
সূত্র

9

ক্লিন? এই কলব্যাক জাহান্নামের দিকে তাকান এবং এটি পরিষ্কার বলে? আমি একমত নই ... এবং আমি যুক্ত করব: ++ & - একা ছেড়ে দিন

— এম কেচাচ

22

ভালো কিছু ...for i in 0.stride(to: 10, by: 2)...বা ...for i in (1...10).reverse()...পরিষ্কার ?!

— mad_manny

6

আমি রাজী. 'ক্লিন' যুক্তিটি মূলত সুইফ্টের বাকী অংশগুলির সাথে মূলত স্ববিরোধী t অবজেক্টিভ-সি থেকে আগত, যা বস্তুনিষ্ঠভাবে অশুচি, এটি একটি অ্যাপল ভাষার লক্ষ্য হিসাবে 'ক্লিন' গ্রহণ করা বেশ কঠিন।

— অ্যাড্রিয়ান বার্থোলোমিউ

2

জেসন এবং সুইফ্টকে পার্স করার চেষ্টা করুন এবং আমাকে বলুন যে এটি কতটা পরিষ্কার।

— নিকডেডুড

6

Fix-it featureXcode এই সুস্পষ্ট উত্তর দেয়।

++ increment operatorপুরানো ফ্যাশনযুক্ত value += 1(শর্ট হ্যান্ড অপারেটর) এবং এর -- decrement operatorসাথে প্রতিস্থাপন করুনvalue -= 1

— জয়প্রকাশ দুবে
সূত্র

6

সুইফট 4 জন্য, আপনি পুনরুদ্ধার করতে পারেন ++এবং --জন্য এক্সটেনশন হিসাবে অপারেটরদের Intএবং অন্যান্য ধরনের। এখানে একটি উদাহরণ:

extension Int{
   static prefix func ++(x: inout Int) -> Int {
        x += 1
        return x
    }

    static postfix func ++(x: inout  Int) -> Int {
        defer {x += 1}
        return x
    }

    static prefix func --(x: inout Int) -> Int {
        x -= 1
        return x
    }

    static postfix func --(x: inout Int) -> Int {
        defer {x -= 1}
        return x
    }
}

এটি অন্যান্য ধরনের, যেমন জন্য একই ভাবে কাজ করে UIInt, Int8, Float, Double, ইত্যাদি

আপনি এই রুট ডিরেক্টরিতে কোনও এক্সটেনশানগুলি একক ফাইলে পেস্ট করতে পারেন এবং সেগুলি আপনার অন্য সমস্ত ফাইলের অভ্যন্তরে ব্যবহারের জন্য উপলব্ধ হবে।

আমি এখানে পোস্ট করার সাথে সাথে আমার উত্তরটির জন্য কয়েকটি ডাউন ভোট পেয়েছি। যা আমার কোডটি কীভাবে কাজ করে তার সমালোচনা না করে দার্শনিক মতবিরোধ হিসাবে গ্রহণ করি। এটি পুরোপুরি কার্যকর হয়, যদি আপনি এটি খেলার মাঠে পরীক্ষা করে দেখেন।

আমি এই উত্তরটি পোস্ট করার কারণটি হ'ল কম্পিউটার প্রোগ্রামিং ভাষাগুলি একে অপরের থেকে অপ্রয়োজনীয়ভাবে আলাদা করার সাথে আমি একমত নই।

ভাষার মধ্যে অনেকগুলি মিল থাকার ফলে লোকেরা শিখতে এবং এক ভাষা থেকে অন্য ভাষায় স্যুইচ করা সহজতর করে তোলে।

বিকাশকারীরা সাধারণত একটির পরিবর্তে বেশ কয়েকটি প্রোগ্রামিং ভাষা ব্যবহার করে। কোনও ভাষা থেকে অন্য ভাষায় কোনও সাধারণ মানককরণ না থাকাকালীন, একটি ভাষা থেকে অন্য ভাষায় স্যুইচ করা সত্যিকারের ঝামেলা।

আমি বিশ্বাস করি যে ভাষার প্রয়োজনগুলির মধ্যে কেবল সিনট্যাক্সের পার্থক্য থাকা উচিত এবং এর চেয়ে বেশি কিছু নয়।

ভাষাগুলি যখন "সাহস" আলাদা হয় তখন আমি পছন্দ করি। সত্যিকার অর্থে অনেকগুলি 'সি-সিনট্যাক্স' ভাষা রয়েছে এবং সি অনেক আগে ডিজাইন করা হয়েছিল .. সেখানে ৫০ বছরেরও বেশি সময় ধরে ভাষার অভিজ্ঞতা হয়েছে .. নির্বিশেষে, উত্তরটি অপারেটরদের উপর চাপিয়ে দেয়নি, এখনও একটি upvote।

— ব্যবহারকারী 2864740

5

এখন পর্যন্ত পোস্ট করা কিছু কোডের জেনেরিক সংস্করণ এখানে। আমি অন্যদের মতো একই উদ্বেগের কথা বলব: সুইফটে এগুলি ব্যবহার না করাই সেরা অভ্যাস । আমি সম্মত হই যে ভবিষ্যতে আপনার কোডটি যারা পড়ছেন তাদের পক্ষে এটি বিভ্রান্তিকর হতে পারে।

prefix operator ++
prefix operator --
prefix func ++<T: Numeric> (_ val: inout T) -> T {
    val += 1
    return val
}

prefix func --<T: Numeric> (_ val: inout T) -> T {
    val -= 1
    return val
}

postfix operator ++
postfix operator --
postfix func ++<T: Numeric> (_ val: inout T) -> T {
    defer { val += 1 }
    return val
}

postfix func --<T: Numeric> (_ val: inout T) -> T {
    defer { val -= 1 }
    return val
}

এটি সংখ্যার প্রকারে এক্সটেনশন হিসাবেও লেখা যেতে পারে।

— Doghound
সূত্র

আমি @discardableResultরিটার্ন মানটি অব্যবহৃত হওয়ার বিষয়ে সতর্কবার্তাটি নীরব করতে প্রতিটি ফাংশন যুক্ত করেছি ; অন্যথায় ঠিক আমি যা খুঁজছিলাম

— ডেভিন লেন

4

ডক্স থেকে :

সুইফ্টের বর্ধন / হ্রাস অপারেটরগুলি সি এর একটি বহনযোগ্য ওভার হিসাবে সুইফটের বিকাশের খুব প্রথম দিকে যুক্ত হয়েছিল, এগুলি খুব বেশি বিবেচনা ছাড়াই যুক্ত করা হয়েছিল, এবং তখন থেকে খুব বেশি কিছু নিয়ে ভাবা হয়নি। এই দস্তাবেজটি এগুলিকে এক নতুন চেহারা দেয় এবং শেষ পর্যন্ত আমরা কেবল তাদের পুরোপুরি সরিয়ে ফেলার পরামর্শ দিই কারণ তারা বিভ্রান্ত হয় এবং তাদের ওজন বহন করে না।

— দানিয়েল নাগি
সূত্র

অন্য কথায় এই অপারেশনটি ব্যবহার করা খুব ব্যয়বহুল?

— ওলেগ গর্দিইচুক

2

github.com/apple/swift-evolution/blob/master/proposals/... এখানে আপনি এটি সম্পর্কে পড়তে পারেন, কিন্তু এটা কারণ এটি ব্যয়বহুল নয়, বরং ভাষা নকশা।

— ডানিয়েল নাগি

সুতরাং আমি যখন আন্ডারসন সুইফট সি-স্টাইল বৈশিষ্ট্যের সমর্থন ছেড়ে যাচ্ছি

— ওলেগ গর্ডিচুক

2

@ ওলেগগোর্দিচুক আমি ভালই বলব যে তারা জোর দিয়ে বলতে চান যে সুইফট ওজেক্টিভ-সি এর বিপরীতে সি-এর সুপারসেট নয়।

— ডানিয়েল নাগি

1

@ আপনি যা বলেছেন তা অনেক কিছুই মোটেই বোঝা যায় না। কীভাবে "বিদ্যমান বিকাশকারীদের দিকে লক্ষ্য নয়"? একইভাবে জাভা পিএইচপি বিকাশকারীদের দিকে দৃষ্টি নিবদ্ধ করে না? "বিকাশকারীদের দিকে ঝোঁক নাও থাকতে পারে তাদের দিকে দৃষ্টি নিবদ্ধ করা"? হ্যাঁ, কারণ সেখানে থাকা সমস্ত অ-বিকাশকারী প্রোটোকল ওরিয়েন্টেড প্রোগ্রামিং এবং জেনেরিকের সাহায্যে হাত কামড় দিচ্ছেন। "ভাল ডিজাইন সক্ষম করার একটি উপায়" কেবল এসও দেখুন, আপনি দেখতে পাবেন যে কোনও প্রোগ্রামিং ভাষা "ভাল নকশা সক্ষম করতে পারে না"।

— ফোগমিস্টার

0

var value : Int = 1

func theOldElegantWay() -> Int{
return value++
}

func theNewFashionWay() -> Int{
let temp = value
value += 1
return temp
}

এটি অবশ্যই একটি খারাপ দিক, তাই না?

— নির্বাসিত
সূত্র

5

আপনার মার্জিত অর্থ যেমন "সি প্রোগ্রামিং ভাষার সমস্ত সূক্ষ্মতা আপনাকে মনে রাখতে হবে, অন্যথায় যদি প্রথম কলটি 1 বা 2 ফেরত দেয় তবে তা অবিলম্বে স্পষ্ট হয় না"? আমি মনে করি একটি

— নির্লজ্জ

0

যেহেতু আপনি সত্যিই সুইফট মধ্যে পয়েন্টার সাথে কাজ, এটা ধরণ ইন্দ্রিয় তোলে মুছে ফেলার জন্য ++এবং --আমার মতে অপারেটর। তবে আপনি যদি না বাঁচতে পারেন তবে আপনি এই প্রকল্পে এই সুইফট 5+ অপারেটরের ঘোষণাগুলি যুক্ত করতে পারেন:

@discardableResult
public prefix func ++<T: Numeric>(i: inout T) -> T {
    i += 1
    return i
}

@discardableResult
public postfix func ++<T: Numeric>(i: inout T) -> T {
    defer { i += 1 }
    return i
}

@discardableResult
public prefix func --<T: Numeric>(i: inout T) -> T {
    i -= 1
    return i
}

@discardableResult
public postfix func --<T: Numeric>(i: inout T) -> T {
    defer { i -= 1 }
    return i
}

— LimeRed
সূত্র

-3

সুইফটে ৪.১ এ এটি অর্জন করা যেতে পারে:



    prefix operator ++
    postfix operator ++
    extension Int{
        static prefix func ++(x: inout Int)->Int{
            x += 1
            return x
        }
        static postfix func ++(x: inout Int)->Int{
            x += 1
            return x-1
        }
    }
    //example:
    var t = 5
    var s = t++
    print("\(t) \(s)")

লক্ষ্য করুন যে এই পোস্টে আগের সমাধানগুলির মতো এই সমাধান সত্ত্বেও তারা সুইফট ৪.১ এ আর কাজ করে না এবং এই উদাহরণটি করে। এছাড়াও লক্ষ্য করুন যে উপরের যার মধ্যে উল্লেখ করা হয়েছে যে ++ কেবলমাত্র ++ এর প্রতিস্থাপন তা অপারেটরটিকে সম্পূর্ণরূপে বুঝতে পারেন না কারণ ++ এর সাথে অ্যাসাইনমেন্টটি মিলিয়ে আসলে দুটি অপারেশন, সুতরাং একটি শর্টকাট। আমার উদাহরণে:var s = t++দুটি জিনিস করে: টির জন্য t এর মান নির্ধারণ করুন এবং তারপরে ইনক্রিমেন্ট টি। যদি ++ আগে আসে তবে এটি একই দুটি অপারেশন বিপরীত ক্রমে সম্পন্ন হয়েছে। আমার মতে, কেন এই অপারেটরটিকে অপসারণ করতে হবে (পূর্ববর্তী উত্তরে উল্লিখিত) সম্পর্কে অ্যাপলের যুক্তি কেবল মিথ্যা যুক্তিই নয়, তবুও আমি বিশ্বাস করি এটি একটি মিথ্যা এবং সত্য কারণ হ'ল তারা তাদের সংকলক এটি পরিচালনা করতে পারেনি। এটি তাদের পূর্ববর্তী সংস্করণগুলিতে ঝামেলা দিয়েছে তাই তারা ছেড়ে দিয়েছে। "অপারেটর বুঝতে খুব জটিল, সুতরাং মুছে ফেলা হয়েছে" এর যুক্তিটি অবশ্যই একটি মিথ্যা কারণ সুইফটে অপারেটর রয়েছে আরও জটিল এবং অনেক কম দরকারী যা অপসারণ করা হয়নি। এছাড়াও, প্রোগ্রামিং ভাষার বিশাল অংশ এটির রয়েছে। জাভাস্ক্রিপ্ট, সি, সি #, জাভা, সি ++ এবং আরও অনেক কিছু। প্রোগ্রামাররা আনন্দের সাথে এটি ব্যবহার করে। যার জন্য এই অপারেটরটি বোঝা খুব কঠিন,

সুইফ্টের পিছনে কৌশলটি সহজ: অ্যাপল বিশ্বাস করে প্রোগ্রামারটি বোবা এবং তাই সেই অনুযায়ী আচরণ করা উচিত।

সত্যটি হ'ল 2014 সালের সেপ্টেম্বরে চালু হওয়া সুইফটটি এখনই অন্য কোথাও হওয়ার কথা ছিল। অন্যান্য ভাষাগুলি অনেক দ্রুত বেড়ে ওঠে।

আমি ভাষার গুরুতর ভুলগুলি থেকে শুরু করে গুরুতর ভুলগুলি তালিকাভুক্ত করতে পারি: যেমন মান দ্বারা আটকানো অ্যারেগুলি রেফারেন্স দ্বারা নয় বিরক্তিকরগুলিতে: ভ্যারিয়েডিক পরামিতি ফাংশনগুলি এমন অ্যারে গ্রহণ করতে পারে না যা এর পিছনে পুরো ধারণা। আমি মনে করি না যে অ্যাপলের কর্মচারীদের এমনকি জাভা হিসাবে অন্যান্য ভাষায় দেখার অনুমতি দেওয়া হয়েছে যাতে তারা জানে না যে অ্যাপল হালকা বছর পিছনে রয়েছে। অ্যাপল জাভা কে ভাষা হিসাবে গ্রহণ করতে পারত কিন্তু আজকাল, চ্যালেঞ্জ প্রযুক্তি নয়, অহংকার। যদি তারা কিছু জাভা লেখার জন্য ইন্টেলিজি খুলতে পারত তবে তারা অবশ্যই তাদের ব্যবসায়ের বোঝাপড়াটি বন্ধ করে দিবে যে এই মুহুর্তে তারা পারবে না এবং কখনই ধরা পড়বে না।

— এলাদ লাভি
সূত্র