предотвращение, если операторы

Опция A:

git clone git@github.com:whatever folder-name

Следовательно, для right here использование:

git clone git@github.com:whatever .

Опция B:

Перемещение .git папка, также. Обратите внимание, что .git папка скрыта в большинстве проводников графического файла, так убедиться показать скрытые файлы.

mv /where/it/is/right/now/* /where/I/want/it/
mv /where/it/is/right/now/.* /where/I/want/it/

первая строка захватывает все нормальные файлы, вторая строка захватывает точечные файлы. Это также possibe, чтобы сделать это в одной строке путем включения dotglob (т.е. shopt -s dotglob), но это - вероятно, плохое решение, если Вы задаете вопрос этот ответ ответы.

Еще лучше:

Сохраняют Вашу рабочую копию где-то в другом месте и создают символьную ссылку. Как это:

ln -s /where/it/is/right/now /the/path/I/want/to/use

Для Вас случаются, это было бы чем-то как:

ln -sfn /opt/projectA/prod/public /httpdocs/public

, Который легко мог быть изменен на тест, если бы Вы хотели его, т.е.:

ln -sfn /opt/projectA/test/public /httpdocs/public

, не перемещая файлы. Добавленный -fn в случае, если кто-то копирует эти строки (-f сила, -n, уже избегают некоторых часто нежелательные взаимодействия с и несуществующие ссылки).

, Если Вы просто хотите, чтобы это работало, используйте Опцию A, если кто-то еще собирается посмотреть на то, что Вы сделали, используйте Опцию C.

39
задан Agustin Meriles 18 April 2013 в 11:40
поделиться

19 ответов

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

Тем не менее, ключевая цель ООП - фактически, одна из "опор" - это инкапсуляция. Старое правило «инкапсулируйте то, что меняется», помогает вам избавиться от проблемных операторов if и case, в которых вы пытаетесь учесть каждую опцию в своем объекте. Лучшим решением для работы с ветвями, особыми случаями и т. Д. Является использование чего-то вроде шаблона проектирования «Фабрика» (абстрактная фабрика или фабричный метод - конечно, в зависимости от потребностей).

Например, вместо того, чтобы иметь свой основной цикл кода проверяет, какую ОС вы используете, с операторами if, затем переходите для создания окон графического интерфейса с различными параметрами для каждой ОС, ваш основной код создаст объект из фабрики, которые используют ОС, чтобы определить, какой конкретный объект для ОС нужно создать. При этом вы извлекаете варианты (и длинные предложения if-then-else) из основного цикла кода и позволяете дочерним объектам обрабатывать его, поэтому в следующий раз вам нужно будет внести изменения, такие как поддержка новой ОС , вы просто добавляете новый класс из интерфейса фабрики.

0
ответ дан 27 November 2019 в 02:11
поделиться

Я скажу, что ответ неопределенно да-иш. Особенно, когда язык допускает тяжелое функциональное программирование (например, C #, F #, OCaml).

Компонент, содержащий 2 оператора if, сильно связывает два бизнес-правила, поэтому разбейте его.

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

0
ответ дан 27 November 2019 в 02:11
поделиться

Я думаю, что применение этого аргумента к идее каждого оператора if довольно экстремально, но некоторые языки дают вам возможность применить эту идею в определенных сценариях.

Вот пример реализации Python I писал в прошлом для двухсторонней очереди фиксированного размера (двусторонняя очередь). Вместо того, чтобы создавать метод «remove» и иметь внутри него операторы if для проверки, заполнен ли список или нет, вы просто создаете два метода и при необходимости переназначаете их функции «remove».

В следующем примере перечислены только "remove", но очевидно, что существуют также "append" методы и т.п.

class StaticDeque(collections.deque):

    def __init__(self, maxSize):

        collections.deque.__init__(self)
        self._maxSize = int(maxSize)
        self._setNotFull()

    def _setFull(self):

        self._full = True
        self.remove = self._full_remove

    def _setNotFull(self):

        self._full = False
        self.remove = self._not_full_remove

    def _not_full_remove(self,value):

        collections.deque.remove(self,value)

    def _full_remove(self,value):

        collections.deque.remove(self,value)
        if len(self) != self._maxSize and self._full:
            self._setNotFull()

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

0
ответ дан 27 November 2019 в 02:11
поделиться

Разумеется, какое-то сравнение нужно проводить независимо от того, что вы делаете? В конце концов ... конечно, вы можете избежать операторов if, но вы будете создавать код, ИДЕНТИЧНЫЙ коду, используя оператор if.

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

0
ответ дан 27 November 2019 в 02:11
поделиться

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

If-операторы определенно занимают свое место в объектно-ориентированном дизайне.

0
ответ дан 27 November 2019 в 02:11
поделиться

Я думаю, что то, что он говорит, или то, что он хочет сказать, это то, что, по его мнению, лучше всего избегать чрезмерного злоупотребления «тегированием» и добавления пользовательских функций к классу несколькими операторами if, когда имеет смысл создать подкласс или переосмыслить иерархию объектов.

1
ответ дан 27 November 2019 в 02:11
поделиться

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

1
ответ дан 27 November 2019 в 02:11
поделиться

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

2
ответ дан 27 November 2019 в 02:11
поделиться

В ответ на вопрос ifTrue:

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

class Nat {
    def cond = {
        print this;
        return this;
    }
}

class NatLessThan<5:Nat> { // subclass of Nat
    override cond = {
        return 0;
    }
}

x = x.cond();

(продолжение ...)

Или, без открытых классов, но предполагающих множественные диспетчерские и анонимные классы:

class MyCondFunctor {
    function branch(Nat n) {
        print n;
        return n;
    }

    function branch(n:NatLessThan<5:Nat>) {
        return 0;
    }
}

x = new MyCondFunctor.branch(x);

Или, как раньше, но с анонимными классами:

x = new {
    function branch(Nat n) {
        print n;
        return n;
    }

    function branch(n:NatLessThan<5:Nat>) {
        return 0;
    }
}.branch(x);

You ' Конечно, мне было бы намного легче, если бы вы переработали эту логику. Помните, что существуют полностью полные по Тьюрингу системы типов.

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

class Nat {
    def cond = {
        print this;
        return this;
    }
}

class NatLessThan<5:Nat> { // subclass of Nat
    override cond = {
        return 0;
    }
}

x = x.cond();

(продолжение ...)

Или, без открытых классов, но предполагающих множественные диспетчерские и анонимные классы:

class MyCondFunctor {
    function branch(Nat n) {
        print n;
        return n;
    }

    function branch(n:NatLessThan<5:Nat>) {
        return 0;
    }
}

x = new MyCondFunctor.branch(x);

Или, как раньше, но с анонимными классами:

x = new {
    function branch(Nat n) {
        print n;
        return n;
    }

    function branch(n:NatLessThan<5:Nat>) {
        return 0;
    }
}.branch(x);

You ' Конечно, мне было бы намного легче, если бы вы переработали эту логику. Помните, что существуют полностью полные по Тьюрингу системы типов.

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

class Nat {
    def cond = {
        print this;
        return this;
    }
}

class NatLessThan<5:Nat> { // subclass of Nat
    override cond = {
        return 0;
    }
}

x = x.cond();

(продолжение ...)

Или, без открытых классов, но предполагающих множественные диспетчерские и анонимные классы:

class MyCondFunctor {
    function branch(Nat n) {
        print n;
        return n;
    }

    function branch(n:NatLessThan<5:Nat>) {
        return 0;
    }
}

x = new MyCondFunctor.branch(x);

Или, как раньше, но с анонимными классами:

x = new {
    function branch(Nat n) {
        print n;
        return n;
    }

    function branch(n:NatLessThan<5:Nat>) {
        return 0;
    }
}.branch(x);

You ' Конечно, мне было бы намного легче, если бы вы переработали эту логику. Помните, что существуют полностью полные по Тьюрингу системы типов.

3
ответ дан 27 November 2019 в 02:11
поделиться

Я ' В последнее время я следил за разговорами против «если», и для меня это звучит как крайняя / гиперболическая риторика. Однако я думаю, что в этом утверждении есть правда: часто логика оператора if может быть более подходящим образом реализована через полиморфизм. Я думаю, что хорошо помнить об этом каждый раз, когда вы исправляете оператор if. При этом я думаю, что оператор if по-прежнему является базовой логической структурой, и его не следует опасаться или избегать как принцип.

0
ответ дан 27 November 2019 в 02:11
поделиться

Это зависит от того, что сравнивает исходный оператор. Мое эмпирическое правило состоит в том, что если это переключатель или , если проверяет равенство по перечислению, то это хороший кандидат для отдельного метода. Однако операторы switch и if используются для многих, многих других видов тестов - нет хорошего способа заменить операторы отношения ( <, > , <= , > = ) со специализированными методами, а некоторые виды перечислимых тестов намного лучше работают со стандартными операторами.

Поэтому вам следует заменить только if , если они выглядят следующим образом:

if (obj.Name == "foo" || obj.Name == "bar") { obj.DoSomething(); }
else if (obj.Name == "baz") { obj.DoSomethingElse(); }
else { obj.DoDefault(); }
3
ответ дан 27 November 2019 в 02:11
поделиться

Как решить, какой метод объекта использовать без оператора if ?

3
ответ дан 27 November 2019 в 02:11
поделиться

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

4
ответ дан 27 November 2019 в 02:11
поделиться

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

6
ответ дан 27 November 2019 в 02:11
поделиться

Да, это правда, что часто сложные условные выражения можно упростить с помощью полиморфизма. Но это не всегда полезно. Прочтите книгу Фаулера «Рефакторинг», чтобы понять, когда.

http://www.refactoring.com/catalog/replaceConditionalWithPolymorphism.html

10
ответ дан 27 November 2019 в 02:11
поделиться

Полное исключение операторов if нереалистично, и я не думаю, что это то, что Ори предполагает. Но часто их можно заменить с помощью полиморфизма. (И то же самое можно сказать о переключателях.)

Франческо Чирилло начал кампанию Anti-If , чтобы привлечь внимание к этой проблеме. Он говорит:

Знание того, как использовать объекты, позволяет разработчикам исключать IF на основе типа,

8
ответ дан 27 November 2019 в 02:11
поделиться

Объясните, как реализовать следующее без оператора if или тернарной логики:

if ( x < 5 ) {
   x = 0
} else {
   print x;
}
13
ответ дан 27 November 2019 в 02:11
поделиться

Взгляните на Кампанию Anti-If Идея не в том, чтобы заменять все if в вашем приложении на Стратегию или Паттерн Состояния. Идея состоит в том, что когда у вас сложная логика ветвления, особенно основанная на чем-то вроде перечисления, вам следует обратить внимание на рефакторинг в соответствии с шаблоном стратегии.

И в этом случае вы можете удалить все if, используя Factory. Вот относительно простой пример. Конечно, как я сказал в реальном случае, логика в ваших стратегиях будет немного сложнее, чем просто распечатать «Я активен».

public enum WorkflowState
{
  Ready,
  Active,
  Complete
}

public interface IWorkflowStrategy
{
  void Execute();
}

public class ActiveWorkflowStrategy:IWorkflowStrategy
{
  public void Execute()
  {
    Console.WriteLine("The Workflow is Active");
  }
}

public class ReadyWorkflowStrategy:IWorkflowStrategy
{
  public void Execute()
  {
    Console.WriteLine("The Workflow is Ready");
  }
}

public class CompleteWorkflowStrategy:IWorkflowStrategy
{
  public void Execute()
  {
    Console.WriteLine("The Workflow is Complete");
  }
}

public class WorkflowStrategyFactory
{
  private static Dictionary<WorkflowState, IWorkflowStrategy> _Strategies= 
    new Dictionary<WorkflowState, IWorkflowStrategy>();
  public WorkflowStrategyFactory()
  {
    _Strategies[WorkflowState.Ready]=new ReadyWorkflowStrategy();
    _Strategies[WorkflowState.Active]= new ActiveWorkflowStrategy();
    _Strategies[WorkflowState.Complete = new CompleteWorkflowStrategy();
  }
  public IWorkflowStrategy GetStrategy(WorkflowState state)
  {
    return _Strategies[state];
  }
}

public class Workflow
{
    public Workflow(WorkflowState state)
    {
        CurrentState = state;
    }
    public WorkflowState CurrentState { get; set; }
}

public class WorkflowEngine
{
    static void Main(string[] args)
    {
        var factory = new WorkflowStrategyFactory();
        var workflows =
            new List<Workflow>
                {
                    new Workflow(WorkflowState.Active),
                    new Workflow(WorkflowState.Complete),
                    new Workflow(WorkflowState.Ready)
                };
        foreach (var workflow in workflows)
        {
            factory.GetStrategy(workflow.CurrentState).
                Execute();
        }
    }
}   
5
ответ дан 27 November 2019 в 02:11
поделиться

My two bits here of what I understand of the Object Oriented approach -

First, what objects in a program should be intuitive. That is, I should not try to create a 'Arithmatic' class to provide mathematical functions. This is an abuse of OOD.

Second and this is a very strong opinion of mine. It should not be called Object Oriented design but Object and Method Oriented design! If the method names of the objects are themselves not intuitive then inherited objects might end up reimplementing the methods already available.

Object Oriented approach, according to me, is not a replacement for the Procedural approach. Rather it is mainly for two main reasons for the creators of the language -

  1. Better capability of scoping of variables.

  2. Better capability of garbage collection rather than having too many global variables.

0
ответ дан 27 November 2019 в 02:11
поделиться
Другие вопросы по тегам:

Похожие вопросы: