De um modo geral, todos ouvimos sobre as funções ou procedimentos nas linguagens de programação. No entanto, acabei de descobrir que uso esses termos quase de forma intercambiável (o que provavelmente está muito errado).

Então, minha pergunta é:

Qual é a diferença em termos de funcionalidade, finalidade e uso?

Um exemplo seria apreciado.

Uma função retorna um valor e um procedimento apenas executa comandos.

A função nome vem da matemática. É usado para calcular um valor com base na entrada.

Um procedimento é um conjunto de comandos que podem ser executados em ordem.

Na maioria das linguagens de programação, até as funções podem ter um conjunto de comandos. Portanto, a diferença está apenas no retorno de uma parte do valor.

Mas se você gosta de manter uma função limpa (basta olhar para as linguagens funcionais), é necessário garantir que uma função não tenha efeito colateral.

Isso depende do contexto.

Nas linguagens do tipo Pascal, funções e procedimentos são entidades distintas, diferindo se retornam ou não um valor. Eles se comportam de maneira diferente. a sintaxe da linguagem (por exemplo: procedure chama instruções de formulário; você não pode usar uma chamada de procedimento dentro de uma expressão vs. chamadas de função não formam instruções, você deve usá-las em outras instruções). Portanto, os programadores criados em Pascal diferenciam esses.

Nas línguas do tipo C e em muitas outras línguas contemporâneas, essa distinção se foi; em idiomas estaticamente tipados, procedimentos são apenas funções com um tipo de retorno engraçado. Provavelmente é por isso que eles são usados ​​de forma intercambiável.

Nas linguagens funcionais, normalmente não existe um procedimento - tudo é uma função.

Exemplo em C:

// function
int square( int n ) {
   return n * n;
}

// procedure
void display( int n ) {
   printf( "The value is %d", n );
}

Embora você deva observar que o padrão C não fala sobre procedimentos, apenas funciona.

Em geral, um procedimento é uma sequência de instruções.
Uma função pode ser a mesma, mas geralmente retorna um resultado.

Existe um termo sub - rotina ou subprograma que significa um pedaço de código parametrizado que pode ser chamado de diferentes lugares.

Funções e procedimentos são implementações dessas. Normalmente, as funções retornam valores e os procedimentos não retornam nada.

Diferenças básicas

• Uma Função deve retornar um valor, mas em Procedimentos Armazenados é opcional: um procedimento pode retornar valores 0 ou n .
• As funções podem ter apenas parâmetros de entrada, enquanto os procedimentos podem ter parâmetros de entrada / saída.
• Para uma Função, é obrigatório usar um parâmetro de entrada, mas um Procedimento Armazenado pode levar de 0 a n parâmetros de entrada.
• As funções podem ser chamadas de um Procedimento, enquanto os Procedimentos não podem ser chamados de uma Função.

Diferenças avançadas

• Exceções podem ser tratadas por blocos try-catch em um Procedimento, enquanto um bloco try-catch não pode ser usado em uma Função.
• Podemos ir para o Gerenciamento de transações em um procedimento, enquanto em uma função não podemos.

No SQL:

• Um procedimento permite SELECT, bem como DML ( INSERT, UPDATE, DELETE) declarações na mesma, enquanto que a função só permite SELECTdeclaração nele.
• Os procedimentos não podem ser utilizados em uma SELECTinstrução, enquanto que Funções podem ser incorporadas em uma SELECTinstrução.
• Os procedimentos armazenados não podem ser usados ​​em instruções SQL em nenhum lugar de um bloco WHERE(ou a HAVINGou a SELECT), enquanto as funções podem.
• As funções que retornam tabelas podem ser tratadas como outro conjunto de linhas. Isso pode ser usado em um JOINbloco com outras tabelas.
• As funções embutidas podem ser vistas como vistas que aceitam parâmetros e podem ser usadas em JOINblocos e outras operações de conjunto de linhas.

Mais estritamente, uma função f obedece à propriedade que f (x) = f (y) se x = y, ou seja, calcula o mesmo resultado cada vez que é chamada com o mesmo argumento (e, portanto, não altera o estado do sistema.)

Portanto, rand () ou print ("Hello") etc. não são funções, mas procedimentos. Embora o sqrt (2.0) deva ser uma função: não há efeito observável ou mudança de estado, independentemente da frequência com que alguém o chame e ele retorne sempre 1,41 e alguns.

Se formos independentes da linguagem aqui, o procedimento geralmente especifica uma série de atos necessários para alcançar de maneira confiável e idempotente determinado resultado. Ou seja, um procedimento é basicamente um algoritmo.

Funções, por outro lado, é um pedaço de código um tanto independente em um programa maior. Em outras palavras, função é a implementação de um procedimento.

Essa é uma pergunta antiga bem conhecida, mas eu gostaria de compartilhar mais algumas idéias sobre pesquisa e design de linguagem de programação moderna.

Resposta básica

Tradicionalmente (no sentido de programação estruturada ) e informalmente, um procedimento é uma construção estrutural reutilizável para "entrada" e para fazer algo programável. Quando algo é necessário para ser feito dentro de um procedimento, você pode fornecer argumentos (reais) para o procedimento em uma chamada de procedimento codificada no código-fonte (geralmente em um tipo de expressão) e as ações codificadas no corpo dos procedimentos (fornecido na definição do procedimento) será executado com a substituição dos argumentos nos parâmetros (formais) usados ​​no corpo.

Uma função é mais do que um procedimento porque os valores de retorno também podem ser especificados como "saída" no corpo. As chamadas de função são mais ou menos iguais às chamadas de procedimento, exceto que você também pode usar o resultado da chamada de função sintaticamente (geralmente como uma subexpressão de alguma outra expressão).

Tradicionalmente, chamadas de procedimento (em vez de chamadas de função) são usadas para indicar que nenhuma saída deve estar interessada e deve haver efeitos colaterais para evitar que a chamada não seja operacional, enfatizando o paradigma de programação imperativa . Muitas linguagens de programação tradicionais como o Pascal fornecem "procedimentos" e "funções" para distinguir essa diferença intencional de estilos.

(Para ficar claro, a "entrada" e a "saída" mencionadas acima são noções simplificadas baseadas nas propriedades sintáticas das funções. Muitos idiomas também suportam a passagem de argumentos para parâmetros por referência / compartilhamento, para permitir que os usuários transportem informações codificadas nos argumentos durante as chamadas. Esse parâmetro pode até ser chamado apenas de "parâmetro de entrada / saída". Esse recurso baseia-se na natureza dos objetos transmitidos nas chamadas, ortogonais às propriedades do recurso do procedimento / função.)

No entanto, se o resultado de uma chamada de função não for necessário, ele pode ser apenas (pelo menos logicamente) ignorado, e as definições de função / chamadas de função devem ser consistentes com as definições de procedimento / chamadas de procedimento dessa maneira. Linguagens do tipo ALGOL, como C, C ++ e Java, todas fornecem o recurso de "função" dessa maneira: codificando o tipo de resultado voidcomo um caso especial de funções parecidas com procedimentos tradicionais, não há necessidade de fornecer o recurso de "procedimentos "separadamente. Isso evita inchaço no design da linguagem.

Como o SICP é mencionado, também é importante notar que, na linguagem do esquema especificada por R ⁿ RS , um procedimento pode ou não precisar retornar o resultado da computação. Esta é a união da "função" tradicional (retornando o resultado) e do "procedimento" (retornando nada), essencialmente igual ao conceito de "função" de muitas linguagens semelhantes ao ALGOL (e compartilhando ainda mais garantias, como avaliações aplicativas do operandos antes da chamada). No entanto, diferenças à moda antiga ainda ocorrem mesmo em documentos normativos como o SRFI-96 .

Não sei muito sobre as razões exatas por trás da divergência, mas, como experimentei, parece que os designers de linguagem ficarão mais felizes sem as incertezas da especificação atualmente. Ou seja, "procedimento" como um recurso independente é desnecessário. Técnicas como o voidtipo já são suficientes para marcar o uso em que os efeitos colaterais devem ser enfatizados. Isso também é mais natural para os usuários que têm experiências em idiomas do tipo C, populares por mais de algumas décadas. Além disso, evita o constrangimento em casos como R ⁿ RS, onde "procedimentos" são realmente "funções" no sentido mais amplo.

Em teoria, uma função pode ser especificada com um tipo de unidade especificado como o tipo do resultado da chamada de função para indicar que o resultado é especial. Isso distingue os procedimentos tradicionais (onde o resultado de uma chamada é desinteressado) dos outros. Existem diferentes estilos no design de um idioma:

• Como no R ⁿ RS, apenas marcar os resultados desinteressados ​​como valor "não especificado" (de tipo não especificado, se o idioma precisar mencioná-lo) e é suficiente para ser ignorado.
• Especificando o resultado indiferente como o valor de um tipo de unidade específica (por exemplo Kernel 's #inert) também funciona.
• Quando esse tipo é mais um tipo inferior , pode (espero) ser estaticamente verificado e evitado usado como um tipo de expressão. O voidtipo em idiomas semelhantes ao ALGOL é exatamente um exemplo dessa técnica. O ISO C11 _Noreturné semelhante, mas mais sutil, nesse tipo.

Leitura adicional

Como o conceito tradicional derivado da matemática, há toneladas de magia negra que a maioria das pessoas não se importa em conhecer. A rigor, você provavelmente não esclarecerá tudo isso de acordo com seus livros de matemática. Os livros de CS também podem não fornecer muita ajuda.

No que diz respeito às linguagens de programação, existem várias advertências:

• Funções em diferentes ramos da matemática nem sempre são definidas com os mesmos significados. As funções em diferentes paradigmas de programação também podem ser bem diferentes (mesmo às vezes as sintaxes das chamadas de função são semelhantes). Às vezes, as razões para causar as diferenças são as mesmas, mas às vezes não são.
  • É idiomático modelar a computação por funções matemáticas e depois implementar a computação subjacente nas linguagens de programação. Tome cuidado para não mapeá-los individualmente, a menos que saiba do que está sendo falado.
• Não confunda o modelo com a entidade a ser modelada.
  • O último é apenas uma das implementações para o primeiro. Pode haver mais de uma opção, dependendo dos contextos (os ramos da matemática interessados, por exemplo).
  • Em particular, é mais ou menos igualmente absurdo tratar "funções" como "mapeamentos" ou subconjuntos de produtos cartesianos, como tratar números naturais como codificação Von-Neumann de ordinais (parecendo um monte de {{{}}, {}}...) além de alguns contextos limitados .
• Matematicamente, as funções podem ser parciais ou totais . Diferentes linguagens de programação têm tratamento diferente aqui.
  • Algumas linguagens funcionais podem honrar a totalidade das funções para garantir que o cálculo nas chamadas de função sempre termine em etapas finitas. No entanto, isso não é essencialmente completo de Turing, portanto, expressividade computacional mais fraca e pouco vista em linguagens de uso geral, além da semântica da digitação tipográfica (que se espera que seja total).
  • Se a diferença entre os procedimentos e funções for significativa, deve haver "procedimentos totais"? Hmm...
• Construções semelhantes às funções nos cálculos usadas para modelar a computação geral e a semântica das linguagens de programação (por exemplo, abstrações lambda nos cálculos lambda ) podem ter diferentes estratégias de avaliação nos operandos.
  • No tradicional, as reduções nos cálculos puros, bem como nas avaliações de expressões em linguagens funcionais puras , não existem efeitos colaterais que alterem os resultados dos cálculos. Como resultado, os operandos não precisam ser avaliados antes do corpo das construções do tipo funções (porque o invariante para definir "mesmos resultados" é mantido por propriedades como a equivalência de β garantida pela propriedade de Church-Rosser ).
  • No entanto, muitas linguagens de programação podem ter efeitos colaterais durante as avaliações de expressões. Isso significa que estratégias estritas de avaliação, como avaliação aplicativa, não são iguais às estratégias de avaliação não estrita, como chamada por necessidade . Isso é significativo, porque sem a distinção, não há necessidade de distinguir macros de função (ie usadas com argumentos) de funções (tradicionais). Mas, dependendo do sabor das teorias, isso ainda pode ser um artefato. Dito isto, em um sentido mais amplo, macros funcionais (especialmente as higiênicas ) são funções matemáticas com algumas limitações desnecessárias (fases sintáticas). Sem as limitações, pode ser sensato tratar macros semelhantes a funções (de primeira classe) como procedimentos ...
  • Para os leitores interessados ​​neste tópico, considere algumas abstrações modernas .
• Os procedimentos são geralmente considerados fora do escopo da matemática tradicional. Entretanto, na modelagem de cálculos da semântica da linguagem de computação e programação, bem como dos designs contemporâneos da linguagem de programação, pode haver uma família bastante grande de conceitos relacionados que compartilham a natureza "exigível". Alguns deles são usados ​​para implementar / estender / substituir procedimentos / funções. Existem distinções ainda mais sutis.
  • Aqui estão algumas palavras-chave relacionadas: sub - rotinas / (sem pilha / empilhável) corotinas / (continuação não delimitada) continuações ... e até mesmo (sem verificação) exceções .

Na maioria dos contextos: uma função retorna um valor, enquanto um procedimento não. Ambos são pedaços de código agrupados para fazer a mesma coisa.

No contexto de programação funcional (onde todas as funções retornam valores), uma função é um objeto abstrato:

f(x)=(1+x)
g(x)=.5*(2+x/2)

Aqui, f é a mesma função que g, mas é um procedimento diferente.

Procedimento interno, podemos usar instruções DML (Insert / Update / Delete), mas a função Inside não pode usar instruções DML.

O procedimento pode ter ambos os parâmetros de entrada \ saída, mas a função pode ter apenas um parâmetro de entrada.

Podemos usar o bloco Try-Catch no procedimento armazenado, mas na função Não podemos usar o bloco Try-Catch.

Não podemos usar o procedimento armazenado na instrução Select, mas na função podemos usar na instrução Select.

O procedimento armazenado pode retornar valores 0 ou n (máximo 1024), mas a função pode retornar apenas 1 valor obrigatório.

O procedimento armazenado não pode ser chamado de Function, mas podemos chamar a função de Stored Procedure.

Podemos usar a transação no Procedimento Armazenado, mas na função Não podemos usar a transação.

Não podemos usar o Procedimento Armazenado na instrução Sql em nenhum lugar da seção Onde / Ter / selecionar, mas podemos usar a função.

Não podemos ingressar no Stored Procedure, mas podemos ingressar na função.

para mais informações ... clique aqui ... http://dotnet-developers-cafe.blogspot.in/2013/08/difference-between-stored-procedure-and.html

Uma função retorna um valor e um procedimento apenas executa comandos.

A função nome vem da matemática. É usado para calcular um valor com base na entrada.

Um procedimento é um conjunto de comandos que podem ser executados em ordem.

Na maioria das linguagens de programação, até as funções podem ter um conjunto de comandos. Portanto, a diferença está apenas no retorno de uma parte do valor.

Mas se você gosta de manter uma função limpa (basta olhar para as linguagens funcionais), é necessário garantir que uma função não tenha efeito colateral.

A função pode ser usada em uma instrução sql, enquanto o procedimento não pode ser usado em uma instrução sql.

Instruções Insert, Update e Create não podem ser incluídas na função, mas um procedimento pode ter essas instruções.

O procedimento suporta transações, mas as funções não suportam transações.

A função deve retornar um e apenas um valor (outro pode ser retornado pela variável OUT), mas o procedimento retorna tantos conjuntos de dados e valores de retorno.

Os planos de execução de funções e procedimentos são armazenados em cache, portanto, o desempenho é o mesmo nos dois casos.

Eu me oponho a algo que continuo vendo repetidamente na maioria dessas respostas, que o que torna uma função uma função é que ela retorna um valor.

Uma função não é apenas um método antigo que retorna um valor. Não é assim: para que um método seja uma função real, ele deve retornar o mesmo valor sempre com uma entrada específica. Um exemplo de método que não é uma função é o randommétodo na maioria dos idiomas, porque, embora retorne um valor, o valor nem sempre é o mesmo.

Uma função, portanto, é mais semelhante a um mapa (por exemplo, onde x -> x'uma função unidimensional). Essa é uma distinção muito importante entre métodos e funções regulares porque, quando se lida com funções reais, o momento e a ordem em que são avaliadas nunca devem importar onde, pois nem sempre é o caso das não funções.

Aqui está outro exemplo de método que não é uma função, mas que ainda assim retornará um valor.

// The following is pseudo code:
g(x) = {
  if (morning()) {
     g = 2 * x;
  }
  else {
   g = x;
  }
  return g;
}

Objeto ainda mais a noção de que os procedimentos não retornam valores. Um procedimento é apenas uma maneira específica de falar sobre uma função ou método. Portanto, se o método subjacente que seu procedimento define ou implementa retorna um valor, adivinhe o que esse procedimento retorna. Tomemos, por exemplo, o seguinte trecho do SICP :

// We can immediately translate this definition into a recursive procedure 
// for computing Fibonacci numbers:

(define (fib n)
  (cond ((= n 0) 0)
        ((= n 1) 1)
        (else (+ (fib (- n 1))
                 (fib (- n 2))))))

Você já ouviu falar de procedimentos recursivos ultimamente? Eles estão falando sobre uma função recursiva (uma função real) e está retornando um valor e estão usando a palavra "procedure". Então qual é a diferença então?

Bem, outra maneira de pensar em uma função (além do significado mencionado acima) é como uma representação abstrata de um ideal como o numeral 1. Um procedimento é a implementação real dessa coisa. Eu pessoalmente acho que eles são intercambiáveis.

(Observe que, se você ler esse capítulo no link que forneço, poderá achar que um conceito mais difícil de entender não é a diferença entre uma função e um procedimento, mas um processo e um procedimento. Você sabia que um procedimento recursivo pode ter um processo interativo?)

Um análogo para procedimentos são receitas. Por exemplo; suponha que você tenha uma máquina chamada make-piesesta máquina consome ingredientes (fruit, milk, flower, eggs, sugar, heat)e esta máquina retorne a pie.

Uma representação desta máquina pode parecer

make-pies (fruit, milk, flower, eggs, sugar, heat) = {
   return (heat (add fruit (mix eggs flower milk)))
}

Claro que essa não é a única maneira de fazer uma torta.

Nesse caso, podemos ver que:

A       function     is to a     machine
as a    procedure    is to a     recipe
as      attributes   are to      ingredients
as      output       is to       product

Essa analogia é boa, mas é quebrada quando você leva em consideração que, ao lidar com um programa de computador, tudo é uma abstração. Portanto, diferentemente do caso de uma receita para uma máquina, estamos comparando duas coisas que são abstrações; duas coisas que podem muito bem ser a mesma coisa. E eu sustento que eles são (para todos os efeitos) a mesma coisa.

No contexto do db : Stored procedure é o plano de execução pré - compilado , onde as funções não são.

Em termos de С # / Java, função é o bloco de código, que retorna um valor específico, mas procedure é o bloco de código que retorna nulo (nada). Em C # / Java, as funções e os procedimentos mais frequentemente chamam apenas métodos .

    //This is a function
    public DateTime GetCurrentDate()
    {
        return DateTime.Now.Date;
    }

    //This is a procedure(always return void)
    public void LogMessage()
    {
        Console.WriteLine("Just an example message.");
    }

Procedimentos: 1. Procedimentos são as coleções de instruções que definem cálculos parametrizados. 2. Os procedimentos não podem retornar valores.

3. Os procedimentos não podem ser chamados a partir da função.

Funções 1. As funções se assemelham estruturalmente a procedimentos, mas são semanticamente modeladas em funções matemáticas. 2. Pode retornar valores 3. A função pode ser chamada de procedimentos.

Procedimentos e funções são sub-rotinas, a única diferença entre eles é que um procedimento retorna vários valores (ou pelo menos pode fazer), enquanto uma função pode retornar apenas um valor (é por isso que a notação de função é usada em matemática, pois geralmente apenas um valor é encontrado em um determinado momento), embora algumas linguagens de programação não sigam essas regras, essas são suas verdadeiras definições