Падеж перечисления после двоеточия: падежи — Какой падеж употребить после двоеточия? (тире или двоеточие?)

падежи — Какой падеж употребить после двоеточия? (тире или двоеточие?)


Вопрос задан


Изменён
6 лет 9 месяцев назад


Просмотрен
11k раза

Здравствуйте!
Подскажите, пожалуйста, как верно:

«Я видела красивую пару: изящная девушка лет двадцати и высокий мужчина лет тридцати»
или
«Я видела красивую пару: изящную девушку лет двадцати и высокого мужчину лет тридцати»

  • падежи
  • пунктуация

В этом предложении нужно поставить тире, так как распространённое приложение «изящную девушку лет двадцати и высокого мужчину лет тридцати» употреблено в конце предложения, имеет уточняющую, поясняющую информацию. Приложение употребляется в том же падеже, что и определяемое слово ПАРУ: «Я видела красивую пару — изящную девушку лет двадцати и высокого мужчину лет тридцати».






1

Возможны варианты:

«Я видела красивую пару: изящную девушку лет двадцати и высокого мужчину лет тридцати»- однородные члены после обобщающего слова.

«Я видела красивую пару — изящную девушку лет двадцати и высокого мужчину лет тридцати».- может быть поставлено тире вместо двоеточия после обобщающего слова перед группой однородных членов, если однородные члены имеют характер приложения или уточнения:Сказки любят все – и взрослые, и дети. Употребление тире в простом и сложном предложении






1

В данном случае, по-моему, верен второй вариант, так как предложение простое. Однако в сложном предложении согласования, конечно нет (Я видела красивую пару: изящная девушка лет двадцати и высокий мужчина лет тридцати шли по набережной)






4

Думаю, однородные члены должны согласоваться в падеже с обобщающими словами






1









Зарегистрируйтесь или войдите

Регистрация через Google

Регистрация через Facebook

Регистрация через почту

Отправить без регистрации

Почта

Необходима, но никому не показывается

Отправить без регистрации


Почта

Необходима, но никому не показывается




Нажимая на кнопку «Отправить ответ», вы соглашаетесь с нашими пользовательским соглашением, политикой конфиденциальности и политикой о куки


орфография — Склонение после двоеточия


Вопрос задан


Изменён
30 дней назад


Просмотрен
466 раз

Замедление инфляции вызвано влиянием следующих факторов: смещениЕМ сезонного роста издержек, а также снижениЕМ спроса.

Правильны ли окончания? Или надо: смещениЯ и снижениЯ

  • орфография
  • склонение
  • двоеточие






3

Правильно: Замедление инфляции вызвано влияниЕМ следующих факторов: смещениЕМ сезонного роста издержек, а также снижениЕМ спроса.

Здесь согласование в Т.п., обобщающим словом является «влиянием». Как это проверить?

Дело в том, то обобщающее слово и члены однородного ряда грамматически однородны. Это значит, что они относятся к одному главному слову, которое задает им падеж: вызвано влиянием, смещением, снижением.

(Но семантически они неоднородны: одно слово обобщает другие).






15

Розенталь «Справочник по правописанию, произношению, литературному редактированию», §208:

  1. При наличии в предложении обобщающего слова однородные члены должны согласоваться с ним в падеже.

Пример: «Охота с острогою требует трех условий: темной ночи, светлой воды и совершенно ясной погоды» (Акс.).






4









Зарегистрируйтесь или войдите

Регистрация через Google

Регистрация через Facebook

Регистрация через почту

Отправить без регистрации

Почта

Необходима, но никому не показывается

Отправить без регистрации


Почта

Необходима, но никому не показывается




Нажимая на кнопку «Отправить ответ», вы соглашаетесь с нашими пользовательским соглашением, политикой конфиденциальности и политикой о куки


перечисление небуквенных значений в Swift

Мы с коллегами недавно обсуждали эту тему, поскольку тип перечисления Swift уникален для других языков. В таком языке, как Java, где перечисление — это просто класс, наследуемый от перечисления, вы можете иметь статических небуквенных значения, назначенных каждому случаю.

В swift мы не можем найти поддерживаемый способ сделать это. Из документации Swift:

Если значение (известное как «необработанное» значение) предоставлено для каждого случая перечисления, значение может быть строкой, символом или значением любого целочисленного типа или типа с плавающей запятой.

Кроме того, варианты перечисления могут указывать связанные значения любого типа, которые будут храниться вместе с каждым другим значением варианта, подобно объединениям или вариантам в других языках. Вы можете определить общий набор связанных вариантов как часть одного перечисления, каждый из которых имеет различный набор значений соответствующих типов, связанных с ним.

Может показаться, что второй абзац может делать то, что просил @Antonio, но это не так. В примере Swift:

 enum Barcode {
   регистр upc(Int, Int, Int, Int)
   случай qrCode (строка)
}

Но каждое перечисление является экземпляром с разными типами значений (кортеж или строка), и значения внутри них различаются в зависимости от каждого созданного экземпляра перечисления.

Я хотел что-то, что позволяло бы больше, чем ограниченное количество необработанных значений, но каждое перечисление содержало бы один и тот же тип значения (т.е. кортеж, объект и т.д…) и являются статическими.

С помощью моих коллег мы предложили два варианта с разными компромиссами.

Первый — это частный статический словарь перечислением, который содержит желаемый тип значения:

 перечисление FooBarDict {
   случай фу
   корпус бар
   private static let dict = [foo: (x: 42, y: "Ответ на жизнь, вселенную и все такое"),
                              бар: (x: 420, y: «Время вечеринки»)]
   переменная x: Целое? {возврат FooBarDict.dict[self]?. x}
   вар у: Строка? {возврат FooBarDict.dict[self]?.y}
}

Наша проблема с этой реализацией заключается в том, что во время компиляции вы не можете гарантировать, что разработчик полностью включил все случаи перечисления. Это означает, что любые свойства, на которые вы указываете права, должны быть необязательными или возвращать значение по умолчанию.

Чтобы решить эту проблему, мы придумали следующее:

 enum FooBarFunc {
    случай фу
    корпус бар
    Значения typealias = (x: Int, y: String)
    частная функция getValues() -> Values ​​{
        переключиться на себя {
        case .foo: return (x: 42, y: "Ответ жизни, вселенной и всему остальному")
        case .bar: возврат (x: 420, y: "Время вечеринки")
        }
    }
    var x: Int {возврат getValues().x }
    var y: String { return getValues().y }
}

Теперь он исчерпывающий из-за оператора switch в getValues! Разработчик не может добавить новый случай и скомпилировать без явного добавления типа значения.

Мои опасения (возможно, необоснованные) в связи с этим подходом заключаются в том, что он может работать медленнее из-за поиска оператора switch, хотя он может быть оптимизирован так, чтобы быть таким же быстрым, как поиск по словарю. И я не уверен, будет ли он создавать новое значение каждый раз, когда запрашивается свойство перечисления. Я уверен, что мог бы найти ответы на обе эти проблемы, но я уже потратил слишком много времени на это.

Честно говоря, я надеюсь, что просто что-то упускаю из виду в языке, и это легко сделать другим способом.

Изучение перечислений и операторов Switch

Перечисления Swift не так просты в освоении, как некоторые другие аспекты
языка программирования Swift, но с этой функцией вам следует ознакомиться
себя с самого начала в вашем стремлении изучить Swift. Хотя перечисления (перечисления)
встречаются на других языках, Swift использует их, вероятно, более гибко, чем
вы пришли к опыту в других языках.

Перечисления в Swift могут быть строками, символами или любыми
целое/с плавающей запятой. Когда вы вводите перечисление в свой код, часто
имя с использованием синтаксиса верхнего регистра. Это не обязательно, но некоторые предпочитают это… и Apple рекомендует это.
Другие типы, такие как свойства или методы, используют синтаксис нижнего регистра. Мы
полагаясь на более знакомый синтаксис нижнего регистра здесь.

(Если вы только что присоединились к нам, у нас есть множество других микроруководств по Swift: узнайте, как работать с функциями, циклами, строками, наборами, массивами и диспетчером пакетов Swift.) 

enum Seasons

Здесь мы объявили перечисление «Времена года» Опять же, обратите внимание, как оно пишется с большой буквы. Если бы мы объявили константу, она, вероятно, выглядела бы примерно так:

 let годовой сезон

Так зачем использовать Swift Enums?

Приведенные выше примеры являются хорошей отправной точкой в ​​нашем путешествии по перечислениям. Если бы мы использовали константу для объявления времен года, мы могли бы объявить ее так:

 let AnnualSeasons = «Весна, лето, осень, зима»

Хотя это точно, это мало что позволяет нам делать. Это просто
список сезонов; с перечислениями мы объявляем времена года и позволяем им
для использования в другом месте.

Перечисления чем-то похожи на функции, поскольку позволяют заключать некоторую логику в скобки. Чтобы получить аналогичные результаты с перечислением, мы должны сделать это:

 перечислений сезонов {
корпус пружина
чехол лето
случай падения
чехол зима
}

(Обратите внимание, что объявления ‘case’ не обязательно должны быть написаны с заглавной буквы, но вы можете, если хотите. Просто помните: код чувствителен к регистру. Если бы вы вызвали ‘Fall’ позже в этом коде, это не ни на что не ссылается, но «падение» будет работать.)

Здесь мы объявили перечисление «Времена года» и дали каждому сезону
кейс. При этом мы разрешаем использование указанных сезонов позже в нашем коде.
Перечисление содержит логику и контрольные точки в повторно используемом пакете.

Как использовать Swift Enums

Давайте повторим перечисление Seasons с точечным синтаксисом и регистром Switch. После того, как мы объявили Seasons со всеми его вариантами, мы объявляем переменную и ссылаемся на наше перечисление:

 var SeasonNow = Seasons.fall

Объявление переменной позволяет вам вызвать эту переменную и получить
value, потому что перечисления — это типы значений в Swift. Все, что мы делаем, это говорим: «Это
сейчас сезон, и сейчас осень».

Как есть, это мало что дает само по себе. Корпус переключателя поможет. Переключатель позволяет вам перебирать ваше перечисление и предоставлять что-то взамен. Здесь мы будем использовать простой оператор печати, чтобы сообщить пользователю, как одеваться в соответствии с сезоном, в котором он находится:

 switch SeasonNow {
случай .весна:
    print("Круто, надень футболку!")
случай .лето:
    print("Так жарко! Пора искупаться.")
случай .fall:
    print("Стало холодно. Принесите свитер!")
случай .зима:
   print("Собирайтесь, холодно")
}

Давайте немного распакуем это; наверное это немного другое
чем то, к чему вы привыкли.

Во-первых, случай переключения использует имя, которое вы объявили для своего
переменная. Перечисление содержит логику, а ваша переменная позволяет вам получить доступ к
логика. Использование того же имени в случае с коммутатором позволяет вам получить доступ к
переменная.

Думайте об этом как о запертой комнате. Перечисление — это сама комната, полная
всяких прикольных вещей. Переменная — запертая дверь. Ваш случай переключателя
ключ к этой двери; это позволяет вам получить доступ к тому, что внутри, и приходить и уходить
как вы предпочитаете!

После того, как мы вызываем переменную в нашем коммутаторе, мы получаем доступ к тому же
случаи, как объявлено в нашем перечислении. Здесь мы используем точечный синтаксис, который похож на ваш код
говоря: «Хорошо, точка, это должно быть (x), верно?»

Точечный синтаксис абсолютен. Двоеточие после case объявляет, что именно он вернет. Здесь ваш код, по сути, говорит вам, что если сезон точно весна, а вы уверены, он предложит пользователю надеть футболку.

Помнишь, мы звонили по номеру Seasons.fall на нашем сезоне Теперь переменная? При этом мы сообщаем нашему коду, что сейчас Fall, а затем сообщаем оператору печати. В Xcode, если вы введете SeasonNow = Seasons.winter , вместо этого будет напечатано «Укутайся, холодно».

И последнее…

Давайте выполним последнее упражнение по основам работы с перечислениями. Допустим, вы жили в климате, где осень, зима и весна были холодными… но лето было теплым. В этом случае вы всегда будете собираться, если только не лето. Ваш код может выглядеть примерно так:

 перечисление сезонов {
чехол весна, лето, осень, зима
}
var SeasonNow = сезоны.лето
переключить сезон сейчас {
случай .лето:
print («Так жарко! Пора искупаться».)
дефолт:
print («Собери и надень слои».)
}

В одной строке может отображаться несколько обращений. Это наиболее полезно, когда у вас есть оператор «по умолчанию» в вашем случае switch, и вам нужно объявить что-то конкретное только для нескольких случаев (или «перебор» перечисления).