Operatory „++” i „-” zostały wycofane. Xcode 7.3


139

Patrzę na notatki Xcode 7.3 i zauważam ten problem.

Operatory ++ i - zostały wycofane

Czy ktoś mógłby wyjaśnić, dlaczego jest przestarzały? I mam rację, że w nowej wersji Xcode teraz użyjesz zamiast ++tego x += 1;

Przykład:

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

Zrzut ekranu ostrzeżenia


6
Myślę, że to pytanie jest poza zakresem stackoverflow głównie dlatego, że wszystkie zaakceptowane propozycje szybkiej ewolucji można znaleźć na Githubie, możesz przeczytać więcej o przyczynach tej propozycji github.com/apple/swift-evolution/blob/master / propozycje /…
Victor Sigler

7
Poważnie rozważam powrót do Objective-C. Nie warto próbować nadążać za wszystkimi zmianami w Swift.
Greg Brown

3
@OlegGordiichuk Chodzi o to, że pętle for jako styl C również zostałyby usunięte, zobacz ten github.com/Vkt0r/swift-evolution/blob/master/propeals/, więc nie musisz używać więcej operatorów ++i--
Victor Sigler

10
Jak na mój gust jest zbyt wiele przełomowych zmian. Jestem za ulepszeniami, ale tak naprawdę nie chcę spędzać czasu na przepisywaniu znacznych części mojej bazy kodu za każdym razem, gdy pojawi się wydanie Xcode Point.
Greg Brown

4
@Fogmeister Nie jestem pewien, jak mógłbym wyrazić się jaśniej. Wolałbym używać Swift, ale nie czuję, że jest wystarczająco stabilny. W przeszłości intensywnie pracowałem z innymi językami i nigdy nie doświadczyłem tylu przełomowych zmian w tak krótkim czasie. Czuję, że Apple chce, żebyśmy wszyscy przyjęli Swift, ale utrudniają to, niż powinno.
Greg Brown

Odpowiedzi:


210

Pełne wyjaśnienie tutaj z Chrisem Lattner, twórca Swifta. Podsumuję punkty:

  1. To kolejna funkcja, której musisz się nauczyć podczas nauki Swift
  2. Niewiele krócej niż x += 1
  3. Swift to nie C. Nie należy ich przenosić tylko po to, by zadowolić programistów C.
  4. Jego głównym zastosowaniem jest pętla for w stylu C: for i = 0; i < n; i++ { ... }który Swift ma lepsze alternatywy, na przykład for i in 0..<n { ... }(pojawia się również pętla for w stylu C )
  5. Może być trudne do odczytania i utrzymania, np. Jaka jest wartość x - ++xlub foo(++x, x++)?
  6. Chris Lattner tego nie lubi.

Dla zainteresowanych (i dla uniknięcia zgnilizny linków) Lattner ma następujące powody:

  1. Operatorzy ci zwiększają obciążenie związane z nauką Swift jako pierwszego języka programowania - lub w każdym innym przypadku, w którym nie znasz jeszcze tych operatorów z innego języka.

  2. Ich wyrazista przewaga jest minimalna - x ++ jest niewiele krótsze niż x + = 1.

  3. Swift już różni się od C tym, że =, + = i inne operacje podobne do przypisania zwracają Void (z wielu powodów). Te operatory są niezgodne z tym modelem.

  4. Swift ma potężne funkcje, które eliminują wiele typowych powodów, dla których używasz ++ i w pętli for w stylu C w innych językach, więc są one stosunkowo rzadko używane w dobrze napisanym kodzie Swift. Funkcje te obejmują pętlę for-in, zakresy, wyliczanie, mapę itp.

  5. Kod, który faktycznie wykorzystuje wartość wynikową tych operatorów, jest często mylący i subtelny dla czytelnika / osoby obsługującej kod. Zachęcają do stosowania „zbyt skomplikowanego” kodu, który może być uroczy, ale trudny do zrozumienia.

  6. Chociaż Swift ma dobrze zdefiniowaną kolejność oceny, każdy kod, który od niego zależy (jak foo (++ a, a ++)) byłby niepożądany, nawet jeśli byłby dobrze zdefiniowany.

  7. Operatory te mają zastosowanie do stosunkowo niewielu typów: skalarów całkowitych i zmiennoprzecinkowych oraz pojęć podobnych do iteratorów. Nie dotyczą liczb zespolonych, macierzy itp.

Wreszcie, nie spełniają one kryterium „gdybyśmy ich jeszcze nie mieli, czy dodalibyśmy je do Swift 3?”


54
Chodzi mi o to, że prawdziwa odpowiedź to numer 6. W porządku, my (byli programiści C, Java,… programiści) jesteśmy wystarczająco elastyczni :-). Ogólnie rzecz biorąc, w prawdziwym świecie wystarczy mutacja, krzyżowanie i selekcja. Ja, Ty i Cris też, wszyscy jesteśmy wynikami tych trzech operatorów ...
user3441734

5
Punkt 5: W C zawsze były one zależne od implementacji i nikt z żadnym rozsądkiem ich nie zrobił. Po prostu zdefiniuj zachowanie, a my się do tego przyzwyczaimy. Lepsze niż konieczność powrotu i zmiany doskonale starego kodu bez żadnego powodu.
Echelon

3
Podoba mi się punkt 3. Nie możesz być na zawsze przykuty do umowy o dziedzictwo. Uwielbiam C, ale tworzysz nowy język programowania; warto zacząć od tak czystego łupka, jak tego potrzebujesz.
Nicolas Miari,

8
To dlatego, że jabłko lubi zmuszać cię do myślenia tak, jak oni. Myślę, że jest w porządku i jest używany wszędzie tam, gdzie trzeba zwiększyć lub odbarwić zmienną. To nie jest coś, czego „musisz się nauczyć”, bez tego sobie poradzisz. A numer 5 to po prostu słabo napisany kod, jakiego nigdy nie widziałem. Więc to jest # 6. Odrzucenie tego wystarczy, żebym podrapał się w głowę i wyszukał w Google, więc dziękuję za marnowanie czasu Chris.
csga5000

4
@ csga5000 To dość słaby argument, biorąc pod uwagę, że możesz sam zdefiniować operatora, jeśli naprawdę chcesz. Nie ma to nic wspólnego z tym, że jabłko chce, aby ludzie myśleli tak jak oni. Po prostu nie pasuje do języka. Gdyby tego ++nie było w językach C, nikt przy zdrowych zmysłach nie spojrzałby na projekt Swift 3.0 i nie pomyślałby, że ++operator byłby miłym dodatkiem do niego.
overactor

37

Zdaję sobie sprawę, że ten komentarz nie odpowiada na pytanie, ale mogą być osoby szukające rozwiązania, jak utrzymać pracę tych operatorów i takie rozwiązanie można znaleźć na dole. 😇

Osobiście wolę ++i --operatorów. Nie mogę zgodzić się z opinią, że są trudne lub trudne w zarządzaniu. Gdy programista zrozumie, co robią te operatory (i mówimy o całkiem prostych rzeczach), kod powinien być bardzo przejrzysty.

W wyjaśnieniu, dlaczego operatory zostały uznane za przestarzałe, wspomniano, że ich głównym zastosowaniem było pętle w stylu C. Nie wiem o innych, ale osobiście w ogóle nie używam pętli w stylu C i jest jeszcze wiele innych miejsc lub sytuacji, w których operator ++lub --jest przydatny.

Chciałbym również wspomnieć, że varName++zwraca wartość, więc może być używany w przypadku, returngdy varName += 1nie można.

Dla każdego, kto chciałby, aby ci operatorzy pracowali tutaj, jest rozwiązaniem:

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
}

Nie podoba mi się twój return (x - 1)dla operatorów postfiksowych - IMHO jest czystsze, aby zachować semantykę, którą zwracają (kopię) oryginalnej wartości, zamiast tego, co otrzymasz, jeśli to zrobiszx + 1 - 1
Alnitak

Ja też tego nie lubię, ale nie znam żadnego innego (lepszego, czystszego) sposobu na zrobienie tego. Nie do końca rozumiem twój drugi punkt.
0101

1
Rozumiem, nie chciałem tego robić tylko po to, by stworzyć inną zmienną (a raczej stałą w tym przypadku). Jeśli mówimy Inttylko o tym, wynik (x + 1)zostanie przepełniony, co przerwie wykonywanie, a tym samym result - 1nie zostanie nawet uruchomiony. Inne typy danych, jak Doublena przykład, zachowują się jednak inaczej, więc muszę to zbadać.
0101

3
Możesz też deferdo tego użyć . defer { x += 1 }; return x
Tim Vermeulen,

4
dlaczego nie użyć typów ogólnych i napisać to w kilku wierszach?
μολὼν.λαβέ

22

Firma Apple usunęła ++i uprościła ją w inny stary tradycyjny sposób.

Zamiast tego ++musisz pisać +=.

Przykład:

var x = 1

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

Podobnie dla operatora dekrementacji --, musisz pisać-=

Przykład:

var x = 1

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

W przypadku forpętli:

Przykład przyrostu:

Zamiast

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

Możesz pisać:

//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)")
}

Przykład zmniejszenia:

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

Możesz pisać:

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)
}

Mam nadzieję że to pomoże!


Nic nie zastąpili; +=był tam przez cały czas.
Nicolas Miari,

@NicolasMiari Yeah, po prostu edytuj w znacznie lepszym formacie
Sohil R. Memon

@NicolasMiari Czy możesz sprawdzić teraz?
Sohil R. Memon

3
A co z ++ii --i?
Zigii Wong

7

Chris Lattner wyruszył na wojnę przeciwko ++ i -. Pisze: „Kod, który faktycznie wykorzystuje wartość wynikową tych operatorów, jest często zagmatwany i subtelny dla czytelnika / opiekuna kodu. Zachęcają do „zbyt skomplikowanego” kodu, który może być uroczy, ale trudny do zrozumienia… Chociaż Swift ma dobrze zdefiniowaną kolejność oceniania, każdy kod, który od niego zależy (jak foo (++ a, a ++)) byłby niepożądany, nawet jeśli był dobrze zdefiniowany… te nie spełniają kryterium „gdybyśmy ich jeszcze nie mieli, czy dodalibyśmy je do Swift 3?” ”

Firma Apple chciała zachować przejrzysty, przejrzysty, niezrozumiały i bezpośredni język. Dlatego wycofali słowa kluczowe ++ i -.


9
Czysty? Spójrz na to piekło oddzwonienia i nazwij to czystym? Nie zgadzam się ... I dodam: zostaw ++ & - w spokoju
mcatach

22
coś jak ...for i in 0.stride(to: 10, by: 2)...czy ...for i in (1...10).reverse()...jest czyste ?!
mad_manny

6
Zgadzam się. „Czysty” argument jest zasadniczo sprzeczny z resztą Swift. Pochodząc z Objective-C, który jest obiektywnie nieczysty, dość trudno jest zaakceptować „czysty” jako cel języka Apple.
Adrian Bartholomew

2
Spróbuj przeanalizować plik json i szybko i powiedz mi, jaki jest czysty.
nickthedude

6

Zrzut ekranu ostrzeżenia

Fix-it featureZ Xcode daje jasnej odpowiedzi na to.

Rozwiązanie ostrzeżenia

Wymienić ++ increment operatorz old-fashioned value += 1(operator krótki ręki) i -- decrement operatorzevalue -= 1


6

W przypadku Swift 4 można przywrócić operatory ++i --jako rozszerzenia dla Inti innych typów. Oto przykład:

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
    }
}

To działa w ten sam sposób do innych typów, takich jak UIInt, Int8, Float, Double, etc.

Możesz wkleić te rozszerzenia w jednym pliku w katalogu głównym i będą one dostępne do użytku we wszystkich innych plikach.

Zauważyłem tutaj kilka głosów negatywnych na moją odpowiedź, prawie natychmiast po jej opublikowaniu. Które traktuję jako filozoficzną niezgodę, a nie krytykę tego, jak działa mój kod. Działa idealnie, jeśli sprawdzisz to na placu zabaw.

Powodem, dla którego zamieściłem tę odpowiedź, jest to, że nie zgadzam się z tym, aby języki programowania komputerów niepotrzebnie różniły się od siebie.

Wiele podobieństw między językami ułatwia ich naukę i przechodzenie z jednego języka na inny.

Programiści zwykle używają kilku języków programowania, a nie tylko jednego. A przejście z jednego języka na inny jest prawdziwym kłopotem, gdy nie ma konwencji ani wspólnej standaryzacji we wszystkich językach.

Uważam, że różnice składniowe między językami powinny być tylko w takim stopniu, w jakim jest to konieczne, i nie więcej niż to.


Uwielbiam, gdy języki „odważą się” być inne. Szczerze mówiąc, jest zbyt wiele języków „C-syntax”, a język C został zaprojektowany dawno temu .. było ponad 50 lat doświadczenia językowego… niezależnie od tego, ponieważ ta odpowiedź nie była tyradą na temat operatorów, nadal głos za.
user2864740

5

Oto ogólna wersja niektórych dotychczas opublikowanych kodów. Chciałbym wyrazić te same obawy, co inni: najlepszą praktyką jest nie używać ich w Swift. Zgadzam się, że może to być mylące dla osób czytających Twój kod w przyszłości.

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
}

Można to również zapisać jako rozszerzenie typu numerycznego.


Dodałem @discardableResultdo każdej z tych funkcji, aby wyciszyć ostrzeżenie o nieużywanej wartości zwracanej; w przeciwnym razie dokładnie to, czego szukałem.
Devin Lane

4

Z dokumentów :

Operatory inkrementacji / dekrementacji w języku Swift zostały dodane na bardzo wczesnym etapie rozwoju języka Swift, jako przeniesienie z C. Zostały one dodane bez większego zastanowienia i od tamtej pory niewiele się nad nimi zastanawiano. Ten dokument zapewnia im świeże spojrzenie i ostatecznie zaleca, abyśmy po prostu je całkowicie usunęli, ponieważ są mylące i nie niosą ze sobą swojej wagi.


Innymi słowy, ta operacja jest zbyt droga, aby ją zastosować?
Oleg Gordiichuk

2
github.com/apple/swift-evolution/blob/master/propeals/ ... tutaj możesz o tym poczytać, ale nie dlatego, że jest drogi, a raczej język.
Dániel Nagy

Ponieważ i andersen Swift zamierzam porzucić wsparcie dla funkcji w stylu C
Oleg Gordiichuk

2
@OlegGordiichuk cóż, powiedziałbym, że chcą podkreślić, że Swift nie jest nadzbiorem C w przeciwieństwie do Objective-C.
Dániel Nagy

1
@mah, wiele z tego, co powiedziałeś, po prostu nie ma sensu. W jaki sposób „Nie jest zorientowany na istniejących deweloperów”? W ten sam sposób, w jaki Java nie jest zorientowana na programistów PHP? „zorientowany na tych, którzy nie mają ochoty zostać programistami”? Tak, ponieważ wszyscy ci, którzy nie są programistami, odgryzają rękę dzięki programowaniu zorientowanemu na protokół i rodzajom generycznym. „Sposób na dobry projekt” wystarczy spojrzeć na SO, a zobaczysz, że żaden język programowania nie może „umożliwić dobrego projektu”.
Fogmeister

0
var value : Int = 1

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

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

To zdecydowanie wada, prawda?


5
Masz na myśli elegancki, jak w „musisz pamiętać wszystkie subtelności języka programowania C, w przeciwnym razie nie jest od razu oczywiste, czy pierwsze wywołanie zwróci 1 czy 2”? Myślę, że wszyscy możemy poświęcić kilka dodatkowych linii kodu w zamian za nie wydając kilka minut główkowaliśmy znaleźć przyczynę błędu przez głupią pomyłkę ...
Nicolas Miari

0

Ponieważ w Swift nigdy nie pracujesz ze wskaźnikami, moim zdaniem ma sens usunięcie operatorów ++i --. Jeśli jednak nie możesz żyć bez, możesz dodać te deklaracje operatora Swift 5+ do swojego projektu:

@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
}

-3

W Swift 4.1 można to osiągnąć w następujący sposób:



    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)")


Zauważ, że pomimo tego, że to rozwiązanie jest podobne do poprzednich rozwiązań w tym poście, nie działają one już w Swift 4.1 i ten przykład działa. Zauważ również, że ktokolwiek powyżej wspomina, że ​​+ = jest zamiennikiem dla ++, po prostu nie w pełni rozumie operator, ponieważ ++ w połączeniu z przypisaniem to w rzeczywistości dwie operacje, stąd skrót. W moim przykładzie:var s = t++robi dwie rzeczy: przypisuje wartość t do s, a następnie zwiększa t. Jeśli ++ występuje wcześniej, to te same dwie operacje wykonane w odwrotnej kolejności. Moim zdaniem rozumowanie Apple dotyczące tego, dlaczego usunąć tego operatora (wspomniane w poprzednich odpowiedziach), jest nie tylko fałszywym rozumowaniem, ale ponadto uważam, że to kłamstwo, a prawdziwym powodem jest to, że nie mogli zmusić kompilatora do tego. W poprzednich wersjach sprawiało im to kłopoty, więc zrezygnowali. Logika „operatora zbyt skomplikowanego, aby go zrozumieć, stąd usunięta” jest oczywiście kłamstwem, ponieważ język Swift zawiera operatory o wiele bardziej skomplikowane i znacznie mniej przydatne, których nie usunięto. Posiada go również ogromna większość języków programowania. JavaScript, C, C #, Java, C ++ i wiele innych. Programiści chętnie z niego korzystają. Komu trudno jest zrozumieć tego operatora,

Strategia Swift jest prosta: Apple uważa, że ​​programista jest głupi i dlatego powinien być odpowiednio traktowany.

Prawda jest taka, że ​​Swift, uruchomiony we wrześniu 2014 r., Miał już być gdzie indziej. Inne języki rosły znacznie szybciej.

Mogę wymienić wiele głównych błędów w języku, od poważnych: takich jak tablice wklejane według wartości, a nie przez odniesienie, po irytujące: funkcje z parametrami zmiennymi nie mogą zaakceptować tablicy, która jest podstawą jej działania. Nie sądzę, aby pracownicy Apple'a mogli nawet patrzeć na inne języki, takie jak Java, więc nawet nie wiedzą, że Apple jest o lata świetlne w tyle. Apple mogło przyjąć Javę jako język, ale obecnie wyzwaniem nie jest technologia, ale ego. Gdyby otworzyli IntelliJ, aby napisać trochę Javy, z pewnością zamknęliby swoje biznesowe zrozumienie, że w tym momencie nie mogą i nigdy nie nadrobią zaległości.

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.