Q: ¿Cómo separar las palabras que contiene un string en C++? 'Split ' ¿Cuál es la forma más eficiente de separar un string en c++? como el que se muestra en el código, el cual contiene espacios entre las palabras, este es el método que yo estoy usando actualmente.
#include <iostream>
#include <sstream>

int main(int argc, char** argv){

    std::string str("Texto para dividir");
    std::istringstream isstream(str);

    while(!isstream.eof()){

        std::string tempStr;

        isstream >> tempStr;

        std::cout << tempStr << std::endl;
    }

    return 0;
}

A: Lo de elegancia es algo difícil de decir, es cuestión de gustos. Pero la legibilidad del código siempre es importante. Por eso, este código se puede simplificar así: (a mi me parece más legible)
std::string tempStr;
while(isstream >> tempStr) {
    std::cout << tempStr << std::endl;
}

Con lo cual, metiendo todo en una función quedaría algo así:
std::vector<std::string> split_istringstream(std::string str) {
    std::vector<std::string> resultado;
    std::istringstream isstream(str);
    std::string palabra;

    while(isstream >> palabra){
        resultado.push_back(palabra);
    }

    return resultado;
}

Otra alternativa, que incluso permite definir el delimitador (el operador >> de istringstream solo divide la cadena por los espacios - ASCII 32) es utilizar std::getline.
std::vector<std::string> split_getline(std::string str, char delim) {
    std::vector<std::string> resultado;
    std::istringstream isstream(str);
    std::string palabra;

    while(std::getline(isstream, palabra, delim)){
        resultado.push_back(palabra);
    }

    return resultado;
}

Aquí abajo te dejo una comparativa entre ambas opciones, son prácticamente iguales en eficiencia, dejando de un lado los vectores, reservan prácticamente la misma memoria.

A: Normalmente lo eficiente y lo bonito no suelen ir dados de la mano. El código bonito suele tener código excesivo (al menos 'por detrás'), pero en ese caso lo que prima es la legibilidad del código... cuando se persigue la eficiencia lo que se acaba consiguiendo es código menos legible... pero más eficiente (en esto habría que especificiar si la eficiencia se refiere a velocidad de ejecución o a consumo de memoria).
Bueno, ya te han puesto códigos bonitos yo te pongo uno que tira por la vía de la rapidez. ¿Cómo de rápido? pues más o menos un 30%-40% más rápido que la opción del istringstream........ claro que el código ya no queda tan bonito:
std::vector<std::string>
split_iterator(const std::string& str)
{
  std::vector<std::string> resultado;

  std::string::const_iterator itBegin = str.begin();
  std::string::const_iterator itEnd   = str.end();

  int numItems = 1;
  for( std::string::const_iterator it = itBegin; it!=itEnd; ++it )
    numItems += *it==' ';

  resultado.reserve(numItems);

  for( std::string::const_iterator it = itBegin; it!=itEnd; ++it )
  {
    if( *it == ' ' )
    {
      resultado.push_back(std::string(itBegin,it));
      itBegin = it+1;
    }
  }

  if( itBegin != itEnd )
    resultado.push_back(std::string(itBegin,itEnd));

  return resultado;
}

En este caso uso iteradores, lo que evita el sobrecoste de crear y llamar a los métodos istringstream. Además como optimización adicional, antes de separar el string precalculo el número total de elementos. De esta forma evito que el vector tenga que llamar a realloc continuamente.
Un saludo

A: Usando la clase iterator
#include <iterator>
#include <iostream>
#include <string>
#include <sstream>

int main() {
    using namespace std;
    string s = "Texto para dividir";
    istringstream iss(s);
    copy(istream_iterator<string>(iss),
         istream_iterator<string>(),
         ostream_iterator<string>(cout, "\n"));
}

se tendrá por ejemplo la salida:
Texto
para
dividir

Ver ejemplo online!

A: Parecido a la respuesta de Elenasys, también usando iteradores de stream:
template <typename char_type>
using string_collection = std::vector<std::basic_string<char_type>>;

template <typename char_type>
string_collection<char_type> split(const std::basic_string<char_type> &text)
{
    using string = std::basic_string<char_type>;
    using iterator = std::istream_iterator<string, char_type>;

    std::basic_stringstream<char_type> reader(text);
    return {iterator(reader), iterator()};
}

El truco es que se construye en línea el vector<string> en el return de la función split pasando los iteradores de inicio y final del stringstream, esta función split puede usarse así:
int main()
{
    for (const auto &palabra : split("hola don pepito"))
        std::cout << palabra << '\n';
    return 0;
}

Y al usar plantillas debería funcionar con cualquier tipo de cadena (char, wchar_t, char16_t y char32_t).
Puedes ver el código funcionando aquí.

A: Puedes usar boost:
std::string line("prueba,prueba2,prueba3");
std::vector<std::string> strs;
boost::split(strs, line, boost::is_any_of(","));

Las cadenas separadas se copian a strs. Con is_any_of puedes especificar el delimitador. Boost es en general muy eficiente y el código te queda bastante limpio y comprensible.

A: Esta técnica utiliza algunos de los métodos anteriores (iterators, std::copy), añadiendo la posibilidad de particularizar cual es el separador y extendiendo el uso de la técnca a streams multilínea que contienen otras cosas que no son std::string.
Por supuesto el std::copy se puede hacer a un std::vector por simplicidad y afinidad con la pregunta original, se dirige todo a std::cout.
Primero la respuesta directa a la pregunta:
#include <iostream>
#include <iterator>
#include <limits>
#include <sstream>
#include <string>

struct SeparatorReader: std::ctype<char>
{
    template<typename T>
    SeparatorReader(const T &seps): std::ctype<char>(get_table(seps), true) {}

    template<typename T>
    std::ctype_base::mask const *get_table(const T &seps) {
        auto &&rc = new std::ctype_base::mask[std::ctype<char>::table_size]();
        for(auto &&sep: seps)
            rc[static_cast<unsigned char>(sep)] = std::ctype_base::space;
        return &rc[0];
    }
};

int
main(int argc, char *argv[])
{
    std::string str("Texto para dividir");
    std::istringstream stream(str);
    // This says whitespace is only ' '
    stream.imbue(std::locale(stream.getloc(), new SeparatorReader(" ")));

    auto first = std::istream_iterator<std::string>(stream);
    auto last = std::istream_iterator<std::string>();
    auto out = std::ostream_iterator<std::string>(std::cout, "\n");

    std::copy(first, last, out);

    return 0;
}

Con el siguiente resultado:
Texto
para
dividir

Nada nuevo bajo el sol, salvo por la introducción del SeparatorReader. Esta subclase de std::ctype acepta una lista de caracteres (que sea iterable, puede incluso ser un vector de caracteres) y los marca como std::ctype_base::space, es decir como los caracteres a considerar como espacio en blanco.
En el código anterior hemos aplicado " " porque es el separador de la cadena de texto de la pregunta (Nota: '\n' no está incluído como espacio en blanco en el ejemplo)
Una vez introducido el concepto podemos trabajar con otro separador como por ejemplo :.
int
main(int argc, char *argv[])
{
    std::string str("");
    std::istringstream stream(str);
    // This says whitespace is only ':'
    stream.imbue(std::locale(stream.getloc(), new SeparatorReader(":")));

    auto first = std::istream_iterator<std::string>(stream);
    auto last = std::istream_iterator<std::string>();
    auto out = std::ostream_iterator<std::string>(std::cout, "\n");

    std::copy(first, last, out);

    return 0;
}

Con el mismo resultado de antes a pesar de haber cambiado los " " por ":".
Texto
para
dividir

La técnica se vuelve más interesante si la utilizamos para aplicársela la tokenización y conversión de otros tipos como p.ej. int y nos apoyamos en los errores de conversión para detectar hitos mayores.
En el siguiente ejemplo simulamos la lectura de un archivo csv que contiene enteros. En lugar de un std::isstringstream podría tratarse de un  vulgar y corriente.
Como SeparatorReader no ve \n como espacio en blanco, lo que producirá un error de conversión que permite detectar el final de línea, que tendremos que ignorar (pasándolo p.ej a un char desechable)
int
main(int argc, char *argv[])
{
    std::string str("1,2, 3\n4, 5,6\n 7,8,9");
    std::istringstream stream(str);
    // Only ' ' and ',' are whitespace, '\n' will stop int conversion
    stream.imbue(std::locale(stream.getloc(), new SeparatorReader(" ,")));

    auto last = std::istream_iterator<int>();
    auto out = std::ostream_iterator<int>(std::cout, "-");

    while(stream) {
        auto first = std::istream_iterator<int>(stream);  // redo after error needed
        std::copy(first, last, out);
        std::cout << std::endl;  // separate lines

        // Either eof or eol - try to skip eol or else re-meet eof
        stream.clear(); char skip; stream >> skip;
    }
    return 0;
}

Con el siguiente resultado:
1-2-3-
4-5-6-
7-8-9-

A: Una forma de separar un cadena de caracteres es de la siguiente manera
#include <regex>    // para los objetos de expresiones regulares y std::string
#include <vector>   // para el std::vector<std::string>
#include <iterator> // para std::back_inserter
std::vector<std::string> split ( std::string const&, std::regex = std::regex("[^\\s]")
{
   std::vector<std::string> splitted:
   for ( auto it = std::sregex_iterator(str.begin(), str.end(), re);
         it != std::sregex_iterator(); ++it )
   {
      std::back_inserter( splitted ) = it->str();
   }
   return splitted;
}


Q: "Unknown provider: uiGmapGoogleMapApiProvider" al probar con Jasmine código que usa el componente de Google Maps para AngularJS Para un proyecto web en el que estoy participando usamos el componente Angular Google Maps. Este es el código JavaScript que hace referencia al componente y lo inicializa:
var configureGoogleMaps = function(uiGmapGoogleMapApiProvider) {
    uiGmapGoogleMapApiProvider.configure({
        libraries: 'geometry,visualization'
    });
}
configureGoogleMaps.$inject = ['uiGmapGoogleMapApiProvider'];

angular
    .module('shTools.Map', ['uiGmapgoogle-maps'])
    .directive('map', mapDirective)
    .config(configureGoogleMaps);

donde mapDirective define un elemento HTML que contiene el componente de Google Maps.
Esto está funcionando como se espera. El problema es que cuando ejecuto un simple test usando Jasmine con Karma, obtengo el error Unknown provider: uiGmapGoogleMapApiProvider. Por alguna razón no está siendo capaz de encontrar el proveedor.
He intentado crear un mock para forzar la creación de un proveedor con ese nombre, pero no ha funcionado:
angular.module('uiGmapgoogle-maps', [])
    .value('uiGmapGoogleMapApiProvider', {
        configure: function() {}
    });

¿Qué podría estar pasando aquí?

A: Los proveedores de AngularJs de inyectan de forma distinta al resto de servicios por lo que también hay que inyectarlos de forma especial cuando escribes las pruebas con Jasmine.
La forma de hacerlo consiste en crear un módulo falso en el que se inyecta el proveedor
beforeEach(function () {
     // Módulo falso donde se inyecta el proveedor
     angular.module('testApp', function () {})
       .config(['bilingualButtonConfigProvider', function (provider) {
         bilingualButtonConfigProvider = provider;
       }]);
     // Inicializar módulos
     module('myApp', 'testApp');
});

Puedes ver el ejemplo completo aquí
También dejo unos enlaces interesantes:

*Creating Configurable Angular Directives with Providers: en este artículo se puede aprender un poco más del comportamiento de los proveedores

*Testing  angular providers with Jasmine: Otro ejemplo en JsFiddle de pruebas con proveedores (es en el que me he basado yo)

Espero que te ayude


Q: ¿Cómo definir métodos correctamente en TypeScript? Dado el siguiente código en TypeScript
class Persona {
    constructor(public nombre: string, public apellido: string) {
    }

    nombreCompleto1 = () => {
        return this.nombre + " " + this.apellido;
    }

    nombreCompleto2() {
        return this.nombre + " " + this.apellido;
    }
}

var p = new Persona("Juan", "Pérez");

console.log(p.nombreCompleto1());
console.log(p.nombreCompleto2());

Como se puede ver los métodos nombreCompleto1 y nombreCompleto2 hacen lo mismo pero están declarados ligeramente diferente.
Al ejecutarlo en los dos casos se obtiene el resultado esperado:

Juan Pérez
Juan Pérez

¿Cuál es la diferencia entre las dos declaraciones si los dos hacen los mismo y cuál es la forma adecuada de declararlo?

A: En el primer caso:
nombreCompleto1 = () => {
    return this.nombre + " " + this.apellido;
}

estás creando un método de instancia, es equivalente a ejecutar this.nombreCompleto1 = function() {...} en JavaScript.
En el segundo caso:
nombreCompleto2() {
    return this.nombre + " " + this.apellido;
}

estás creando un método de prototipo, es equivalente a Persona.prototype.nombreCompleto2 = function() {...} en JavaScript.
En general es preferible crear métodos de prototipo: en tal caso el método se define una sola vez, mientras que los métodos de instancia se crean una vez por instancia, consumiendo más memoria.
Más información: TypeScript Classes and Interfaces


Q: "splice() offset past end of array" en diferentes versiones de Perl Hoy, en mi trabajo, escribí algo así, en Perl:
my @x = qw( 1 2 3 4 5 );
splice(@x, 10);

y produjo el error:

splice() offset past end of array at ./x line X.

Pero en mi laptop personal, no hay ningún error así. Ya sé que es fácil suprimir el mensaje (en Inglés) con no warnings 'misc';, pero mi pregunta es:
¿Por qué la diferencia entre las versiones de Perl?
En el trabajo, veo el mensaje con Perl 5.14, y en mi equipo personal no lo veo con Perl 5.20.  ¿Cuando lo cambió, y por qué?

A: Como ya mencioné yo no uso Perl, pero mirando la documentación en una parte de ella dice lo siguiente:

"Si el desplazamiento es más allá del final de la matriz, Perl emite
  una advertencia, y (Perl) empalma/splice en el extremo de la matriz."

...If OFFSET is past the end of the array, Perl issues a warning, and splices at the end of the array.
De echo he revisado en varias versiones y es lo mismo por lo menos la documentación advierten sobre el warning.
Aquí le dejo los links (en Inglés);

*Perl v 5.16.2

*Perl v 5.20.0

*Perl v 5.22

Según lo anterior lo normal es el warning, pero por lo que se puede ver en el siguiente link, no en todas las versiones es así y también depende del OS.

Creo que eso ocurre entre la 5.14 y 5.16 en algunos sistemas, aquí puede ver la notificación de bug pero quizás también le suceda a usted en la 5.20 debido a su OS y no es que haya cambiado algo.

A: voy a sumarme con la parte de la pregunta que no se ha respondido aun: ¿Por qué cambió?
Cambio por que la intención de este código:
my @x = qw( 1 2 3 4 5 );
splice(@x, 3);

es claramente truncar el array si es demasiado largo y no hay razon para emitir una advertencia si el array tiene menos elementos que el máximo especificado (como en el caso citado en la pregunta)
Fuente (en Inglés)


Q: ¿Cómo puedo convertir un rango a lista en elixir? Si defino un rango como el siguiente,
rango = 1..5

¿Hay una manera de convertirlo a lista?

A: Creo que esto es lo que usted esta buscando
to_list (colección)
Convierte la colección a una lista
iex> Enum.to_list 1..5
[1, 2, 3, 4, 5]

espero le ayude


Q: ¿Cómo mostrar una vista sin el layout de la aplicación? ¿Cómo se hace para mostrar una Vista (view) de Rails sin mostrar el layout de la aplicación para un usuario registrado y otro layout para un visitante? ¿Se puede?

A: Podes cambiar el layout para un controlador o una acción del controlador, una manera de mostrar una vista con otro layout cuando el usuario no esta registrado seria así:
class MyController < ApplicationController

  def my_action
    if current_user.nil?
      render layout: "new_user_layout"
    else
      render layout: "member_layout"
    end
  end

end

Para cambiar el layout de todos los controladores que heredan de ApplicationController seria lo siguiente:
class ApplicationController < ActionController::Base
  layout :users_layout

  private
    def users_layout
      current_user.nil? ? "new_user_layout" : "member_layout"
    end

end

En las guias de rails podes encontrar más información sobre layouts.

A: este codigo es sino te gustaria usar ningun layout
 class MyController < ApplicationController

      def my_action
        #solo debes poner en modo false para  que lo desabilites solo para este metodo
         render layout: false
      end

    end

o tmb puede ser
class MyController < ApplicationController
layout: false
  def my_action

  end

end


Q: ¿Por qué requestAnimationFrame tarda un tiempo en estabilizarse? Hoy intenté este algoritmo para medir a cuantos cuadros por segundo (FPS) se refresca mi pantalla (yo sé de antemano que son 50 FPS).
function measureFpsAsync() {
    requestAnimationFrame(function(t0) {
        requestAnimationFrame(function(t1) {
            fps = Math.round(1000/(t1 - t0));
            alert(fps);
        });
    });
}
window.onload = measureFpsAsync;

Para mi sorpresa el resultado no fue 50, tampo un resultado estable, algunas veces resulta 25, otras 13, otras 7. Parece que se salta algunos "frames" (o cuadros) entre los callbacks.
Lo probé en Chrome, Firefox y Edge y siempre pasa lo mismo.
Luego intenté envolverlo en un setTimeout a ver que sucedía y funcionó, siempre me devuelve un resultado estable de 50 FPS.
setTimeout(function() {
        measureFpsAsync();
}, 500);

La verdad me sorprende, yo entendía que requestAnimationFrame tenía cierta correlación con el refresco vertical de la pantalla y que se llama a intervalos regulares, ahora no se si este método es seguro para calcular el FPS.
¿Alguien me puede explicar por qué pasa esto?
Es importante para mi, porque estoy creando una coreografía y necesito calcular un epsilon muy preciso.
Es seguro este método o debería moverme a un enfoque que tome mas muestras?

A: El principal problema de la prueba que has realizado está en la propia prueba: Tan sólo haces la prueba de FPS en entre dos fotogramas consecutivos completamente aislados.
La frecuencia de actualización del navegador está obviamente capada por la frecuencia de actualización máxima que permita vsync o, como se muestra en la respuesta de @AngelAngel, por el valor establecido mediante startAnimating, pero se pueden dar casos en los que esta frecuencia sea menor por saturación del proceso de redibujado.
Esto es precisamente lo que ocurre en tu primera prueba: Estás realizando una medida de FPS entre dos fotogramas que muy probablemente estén separados por un redibujado del DOM, teniendo en cuenta que realizas la petición inmediatamente después de que window haya terminado de cargar.  En el segundo caso, pasado medio segundo el proceso de dibujado está estable y por tanto ambos fotogramas llegarán con frecuencia máxima, puesto que no hay nada que hacer entre ellos.

A: Los FPS varian porque solo se solicita un marco cuando es necesario. por ejemplo si la imagen no cambia o es un fondo oscuro la tasa se puede reducir a una tasa más baja, ademas cuando se ejecuta en las pestañas de fondo tambien pude darse el caso para mejorar el rendimiento y la duración de la batería.
Puede mirar este caso como se "ajustan los frames" usando: startAnimating(5);
jsfiddle

var stop = false;
var frameCount = 0;
var $results = $("#results");
var fps, fpsInterval, startTime, now, then, elapsed;

startAnimating(5);

function startAnimating(fps) {
    fpsInterval = 1000 / fps;
    then = Date.now();
    startTime = then;
    console.log(startTime);
    animate();
}

function animate() {

    // stop
    if (stop) {
        return;
    }

    // request another frame

    requestAnimationFrame(animate);

    // calc elapsed time since last loop

    now = Date.now();
    elapsed = now - then;

    // if enough time has elapsed, draw the next frame

    if (elapsed > fpsInterval) {

        // Get ready for next frame by setting then=now, but...
        // Also, adjust for fpsInterval not being multiple of 16.67
        then = now - (elapsed % fpsInterval);

        // draw stuff here

        // TESTING...Report #seconds since start and achieved fps.
        var sinceStart = now - startTime;
        var currentFps = Math.round(1000 / (sinceStart / ++frameCount) * 100) / 100;
        $results.text("Elapsed time= " + Math.round(sinceStart / 1000 * 100) / 100 + " secs @ " + currentFps + " fps.");

    }
}

Throttling requestAnimationFrame to a FPS

This test:  Results should be approximately 5 fps

Results:

<canvas id="canvas" width=300 height=300></canvas>


Q: ¿Cómo puedo saber si un elemento está visible con jQuery? Ya que en jQuery es posible cambiar la visibilidad de un elemento, ¿Cómo puedo saber si un elemento está visible o no en tiempo de ejecución?

A: Es verdad que puedes usar is(":visible") pero por experiencia te recomiendo el uso de clases para que no tengas problemas a la hora de testear tus aplicaciones, ya que muchas librerías de tests no tienen los componentes que se prueban visibles y por mucho que tu componente haga hide() o show() jQuery seguirá indicando que no está visible, y el comportamiento de tus componentes será extraño. Esto me ha pasado con la librería de tests QUnit, de los autores de jQuery.
Lo que yo haría sería: $el.toggleClass("hide") o $el.addClass("hide").
Y comprobarlo con: !$el.hasClass("hide").
Además hay que tener cuidado al usar is(":visible") porque visibility: hidden u opacity: 0 se consideran visibles ya que ocupan espacio en el layout.
Ten en cuenta que mi solución es para comprobar si exclusivamente el elemento está visible. Puede darse el caso de que alguno de los padres no esté visible y por tanto no se vea. Si quieres comprobar algo así quizás es mejor que uses is(":visible") o !$(..).closest(".hide").

A: Puedes usar la función is() junto con el selector :visible sobre un objeto jQuery ya existente.
Por ejemplo, si tienes un div con id: "elemento" puedes saber si éste está visible o no de esta manera:
var esVisible = $("#elemento").is(":visible");

Para mas información revisa la documentación de is y :visible

A: Al igual que emplea jquery el selector :visible en su ejemplo, lo puedes incorporar en la misma expresión de búsqueda del elemento
var visible = $("#").length > 0;

o hacer un filtrado
var visible = $("#element").filter(":visible").length > 0;

Estas formas de filtrado de elementos son particularmente útiles cuando vas a iterar sobre una lista de resultados
$(".").each(function() {
    ...
}

Aunque si sólo necesitas una respuesta booleana, como bien ha escrito Carlos Muñoz, puedes hacerlo así
var isVisible = $("#elemento").is(":visible");

A: Podés usar lo siguiente
if($('#elemento').css('display') == 'none'){
   // Acción si el elemento no es visible
}else{
   // Acción si el elemento es visible
}

en el caso de que tambien queramos chequear la opacidad hacemos:
if($('#elemento').css('display') == 'none' || $('#elemento').css('opacity') == 0){
       // Acción si el elemento no es visible
}else{
       // Acción si el elemento es visible
}

A: Me vi involucrado en éste caso específico donde la solución inicial bastaría con:
if ($elementoDOM.is(':visible')){ console.log('el elemento está visible') }

PERO! mucho ojo que como decía un compañero en otros comentarios ésto no aplica para elementos que tengan la propiedad: opacity:0.
En lo personal lo más usado es con opacity ya que de tal manera se logra animar la aparición/desaparición de elementos en el DOM de una forma estética. Razón por la cual la instrucción precisa que me acaba de funcionar es:
if ($elementoDOM.css('opacity')==1) { ... } ó
if ($elementoDOM.css('opacity')==0) { ... }

tener cuidado de no colocar el numero (0,1) entre comillas dobles o simples!
Un saludo.


Q: ¿Debo utilizar un campo de tipo DateTime o TimeStamp en mySQL? Debo guardar fechas y horas en diferentes tablas de una aplicación típica transaccional dónde voy a almacenar información variada, cómo por ejemplo:

*Fechas y horas a las que ocurre cada transacción (Factura, Recibo de Pago, etc.)

*Fechas y horas de eventos futuros, como citas y entregas programadas

*Fechas pasadas, como la fecha de nacimiento del empleado, o de los hijos del empleado.

Tengo poca experiencia con MySQL y no estoy seguro de qué tipo de dato debo elegir en cada caso.
Qué es lo recomendable, utilizar un campo de tipo DateTime o de tipo TimeStamp y ¿por qué?

A: En algún punto de esta documentación de MySQL expone algo así:
 (link inglés)

TIMESTAMP tiene un rango de '1970-01-01 00:00:01' GMT a '01/09/2038
  03:14:07' GMT.
DATETIME se usa cuando se necesita valores que contienen tanto la
  fecha y la hora. MySQL recupera y muestra los valores DATETIME en
  'AAAA-MM-DD HH: MM: SS' formato. El rango admitido es '01/01/1000
  00:00:00' a '9999-12-31 23:59:59'.

Partiendo de lo anterior y teniéndolo en cuenta es el posible que el rango de los datos que podría almacenar o estar interesado en ello le inclinen a favor de uno u otro, por ejemplo si usted trabaja con hipotecas por decir algo es fácil que usted supere el rango de TIMESTAMP a día de hoy.
TIMESTAMP es afectada por las configuraciones/ajustes de la zona horaria. Mientras que DATETIME es constante.
TIMESTAMP es de cuatro bytes y DATETIME de ocho bytes, por consecuencia las marcas de tiempo (TIMESTAMP) son también más ligeras en la base de datos, con indexados más rápidos.
Teniendo en cuenta todo lo anterior si usted desea almacenar un valor específico "podría que fuese mejor" usar DATATIME, pero si lo que desea es almacenar para realizar algún seguimento de posibles cambios en los registro quizás le convenga usar TIMESTAMP cuando cambia un registro.
Si esta trabajando sobre MySQL 5 o superior, los valores de TIMESTAMP se convierten de la zona horaria actual a UTC para el almacenamiento, y se convierten de nuevo de UTC a la zona horaria actual para la recuperación. sólo para el tipo de datos TIMESTAMP.
(NOTA si encuentro el link de lo anterior lo intentaré poner por aquí)
Espero le ayude.

A:
¿Debo utilizar un campo de tipo DateTime o TimeStamp en mySQL?

Depende de tus requerimientos, existen ciertas consideraciones para cada caso por ejemplo el rango de valores que puede soportar cada uno.

*DATETIME considera valores de fecha y hora  en formato:'YYYY-MM-DD ', el rango soportado: '1000-01-01 00:00:00' a '9999-12-31
  23:59:59'

*TIMESTAMP  También considera valores fecha y hora pero tiene un rango de '1970-01-01 00:00:01' UTC a '2038-01-19 03:14:07' UTC.

mas información:
 Tipos DATE, DATETIME, and TIMESTAMP.
otras propiedades tal vez obvias para muchos de nosotros es la inicialización automática y  actualización a la fecha y hora actual. Valores TIMESTAMP con default de cero no son permitidos en MySql.

A: Yo solo le veo el sentido a usar TimeStamp cuando quieras asegurarte de que dicha fecha se establezca automáticamente cuando se inserte o actualice el registro.
Por ejemplo si quieres guardar la fecha y hora de un evento lo defines así:
CREATE TABLE `eventos`
(
  `Id` int(11) NOT NULL AUTO_INCREMENT,
  `Evento` VarChar(50) NOT NULL DEFAULT '',
  `FechaHora` TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  PRIMARY KEY (`Id`)
);

Fíjate que en el INSERT no incluyes el campo FechaHora.
INSERT INTO eventos(Evento) VALUES('Evento 0001');

SELECT * FROM eventos;

Id
Evento
FechaHora

1
Evento 0001
2021-06-17 18_20_06

Otro ejemplo con UPDATE:
CREATE TABLE `productos`
(
  `Id` int(11) NOT NULL AUTO_INCREMENT,
  `Nombre` VarChar(50) NOT NULL DEFAULT '',
  `Marca` VarChar(50) NOT NULL DEFAULT '',
  `Referencia` VarChar(50) NOT NULL DEFAULT '',
  `FechaModif` TIMESTAMP NULL DEFAULT NULL ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`Id`)
);

INSERT INTO productos (Nombre, Marca, Referencia, FechaModif) VALUES ('MOUSE', 'GENIUS', 'X105', NOW());

SELECT * FROM productos;

Id
Nombre
Marca
Refereencia
FechaModif

1
MOSUE
GENIUS
X105
2021-06-17 19:25:08

UPDATE productos p SET p.Referencia = 'X106' WHERE p.Id = 1;

SELECT * FROM productos;

Id
Nombre
Marca
Refereencia
FechaModif

1
MOSUE
GENIUS
X106
2021-06-17 19:26:42


Q: ¿Cuál es la diferencia entre un inner y un outer join? ¿Cuál es la diferencia entre un inner y un outer join?
Y ¿cuál es la función de los modificadores?

*left

*right

*full

A: Asumiendo que se está haciendo un join de columnas sin duplicados, lo cuál es un caso común:

*Un inner join de A y B entregará el resultado de la intersección de los conjuntos A y B. En otras palabras, la parte interna -intersección- en un diagrama de Venn.

*Un full outer join entre A y B entregará el resultado de la unión de A y B. En otras palabras, la parte externa -unión- en un diagrama de Venn .

Ejemplos:
Supongamos que tenemos dos tablas, con una sola columna cada una y los siguientes datos:
A    B
-    -
1    3
2    4
3    5
4    6

Nota que (1,2) solo se encuentran en A, (3,4) son comunes y (5,6) solamente se encuentran en B.
Inner Join
Un inner join -utilizando cualquiera de las sintaxis de consulta equivalente- te entrega la intersección de ambas tablas, es decir, las filas que ambas tablas tienen en común.
select * from a INNER JOIN b on a.a = b.b;
select a.*, b.*  from a, b where a.a = b.b;

a | b
--+--
3 | 3
4 | 4

Left outer join
Un outer join por la izquierda, te dará todas las filas de A, incluyendo las filas comunes entre A y B.
select * from a LEFT OUTER JOIN b on a.a = b.b;
select a.*,b.*  from a,b where a.a = b.b(+);

a |  b
--+-----
1 | null
2 | null
3 |    3
4 |    4

Right outer join
Un outer join por la derecha te dará todas las filas de B, incluyendo las filas comunes con A.
select * from a RIGHT OUTER JOIN b on a.a = b.b;
select a.*,b.*  from a,b where a.a(+) = b.b;

a    |  b
-----+----
3    |  3
4    |  4
null |  5
null |  6

Full outer join
Un outer join completo (full) te entregará la unión de A y B; es decir, todas las filas de A y todas las filas de B. Si una fila en A no tiene una fila correspondiente en B, la porción de B es null, y vice versa.
select * from a FULL OUTER JOIN b on a.a = b.b;

 a   |  b
-----+-----
   1 | null
   2 | null
   3 |    3
   4 |    4
null |    5
null |    6

Diagramas de Venn
Esto mismo, podemos verlo con diagramas de Venn:

Imagen SQL Joins.svg de Arbeck, compartida bajo licencia CC BY 3.0.

A: Voy a utilizar el mismo ejemplo de jachguate el cual es muy claro agregando unos pequeños detalles.
Glosario

*inner join (traducción libre: Unión interna)

*outer join (traducción libre: Unión externa)

-- Crear tabla A (tabla Izquierda)
CREATE TABLE A
(
a INT
);

-- Crear tabla B (tabla derecha)
CREATE TABLE B
(
b INT
);

-- Insertar datos
Insert into A (a) Values (1);
Insert into A (a) Values (2);
Insert into A (a) Values (3);
Insert into A (a) Values (4);
Insert into B (b) Values (3);
Insert into B (b) Values (4);
Insert into B (b) Values (5);
Insert into B (b) Values (6);
COMMIT;

-- Tabla A
SELECT * FROM A;

-- Tabla B
SELECT * FROM B;

/* Inner Join. */
-- Unión interna, filas que ambas tablas tienen en común.
select * from A INNER JOIN B on A.a = B.b;
select A.*, B.*  from A, B where A.a = B.b;

/* Left outer join */
-- Unión externa por la izquierda, todas las filas de A (tabla izquierda) relacionadas con B, así estas tengan o no coincidencias.
select * from A LEFT OUTER JOIN B on A.a = B.b;
select A.*,B.*  from A,B where A.a = B.b(+);

/* Right outer join */
-- Unión externa por la derecha, todas las filas de B (tabla derecha), así estas tengan o no coincidencias con A.
select * from A RIGHT OUTER JOIN B on A.a = B.b;
select A.*,B.*  from A,B where A.a(+) = B.b;

/* Full outer join */
-- Unión externa completa, unión externa por la izquierda unida a unión externa por la derecha.

-- En oracle:
select * from A FULL OUTER JOIN B on A.a = B.b;

-- En MySql no está implementado FULL OUTER JOIN, para obtener este mismo resultado:

select * from A LEFT OUTER JOIN B on A.a = B.b
UNION
select * from A RIGHT OUTER JOIN B on A.a = B.b;

Ver:

*Esquema en oracle live

*Esquema en sqlfiddle

*Documentación MySql

A: Mis datos para la explicación :

CREATE TABLE Departamentos (
    Id int,
    Nombre varchar(20)
);

CREATE TABLE Empleados (
    Nombre varchar(20),
    DepartamentoId int
);

INSERT INTO Departamentos VALUES(31, 'Sales'),
                                (33, 'Engineering'),
                                (34, 'Clerical'),
                                (35, 'Marketing');

INSERT INTO Empleados VALUES('Rafferty', 31),
                            ('Jones', 33),
                            ('Heisenberg', 33),
                            ('Robinson', 34),
                            ('Smith', 34),
                            ('Williams', NULL);

Ejecutar
Cláusula INNER JOIN
Esta clausula busca coincidencia entre dos tablas, es parecido a la union de tabla de clave primaria que se usaba antiguamente como por ejemplo SELECT * FROM Departamentos, Empleados WHERE Departamentos.Id=Empleados.DepartamentosId;

Por ejemplo : Si quiero listar los empleados y indicar el nombre del departamento al que pertenecen pues podemos realizar lo siguiente :
SELECT *
FROM Empleados E
JOIN Departamentos D
ON E.DepartamentoId = D.Id

Ejecutar
El resultado será :
+----------+------------------+---------+----------------+
|Nombre    |   DepartmentoId  |   Id    |   Nombre       |
+----------+------------------+---------+----------------+
|Rafferty  |        31        |    31   |    Sales       |
|Jones     |        33        |    33   |    Engineering |
|Heisenberg|        33        |    33   |    Engineering |
|Robinson  |        34        |    34   |    Clerical    |
|Smith     |        34        |    34   |    Clerical    |
+----------+------------------+---------+----------------+

Y a partir de aquí nos damos cuentas delo siguiente:

*El empleado "Williams" no aparece en los resultados, ya que no pertenece a ningún departamento que actualmente exista.

*El departamento "Marketing" tampoco aparece, ya que no hay ningún empleado pertenece a dicho departamento.

¿Por qué ocurre esto? Porque muestra como resultado la intersección de ambas tablas.
Hay que tener en cuenta que, en los resultados vemos 4 columnas. Las 2 primeras se corresponden con la tabla Empleados y las últimas con Departamentos.
Esto ocurre porque estamos seleccionando todas las columnas con un Asterisco(*).
Si queremos, podemos ser específicos y seleccionar sólo 2 columnas :
SELECT E.Nombre as 'Empleado',
D.Nombre as 'Departamento'
FROM Empleados E
JOIN Departamentos D
ON E.DepartamentoId = D.Id

Y obtener :
+-----------+-----------------+
| Empleado  |   Departamento  |
+-----------+-----------------+
| Rafferty  |    Sales        |
| Jones     |    Engineering  |
| Heisenberg|    Engineering  |
| Robinson  |    Clerical     |
| Smith     |    Clerical     |
+-----------+-----------------+

Ejecutar
Cláusula LEFT JOIN
A diferencia de un INNER JOIN con LEFT JOIN damos prioridad a la tabla de la izquierda, y buscamos en la tabla derecha.
Si no existe ninguna coincidencia para alguna de las filas de la tabla de la izquierda, de igual forma todos los resultados de la primera tabla se muestran.

Un ejemplo:
SELECT E.Nombre as 'Empleado', D.Nombre as 'Departamento'
FROM Empleados E
LEFT JOIN Departamentos D
ON E.DepartamentoId = D.Id

*La tabla Empleados es la primera tabla en aparecer en la consulta (en el FROM), por lo tanto ésta es la tabla LEFT (izquierda), y todas sus filas se mostrarán en los resultados.

*La tabla Departamentos es la tabla de la derecha (aparece luego del LEFT JOIN). Por lo tanto, si se encuentran coincidencias, se mostrarán los valores correspondientes, pero sino, aparecerá NULL en los resultados.

+------------+---------------+
| Empleado   |  Departamento |
+------------+---------------+
| Rafferty   |  Sales        |
| Jones      |  Engineering  |
| Heisenberg |  Engineering  |
| Robinson   |  Clerical     |
| Smith      |  Clerical     |
| Williams   |  NULL         |
+------------+---------------+

Ejecutar
Cláusula RIGHT JOIN
En el caso de RIGHT JOIN es muy similar, pero aquí se da prioridad a la tabla de la derecha.

De tal modo que si uso la siguiente consulta, estamos mostrando todas las filas de la tabla de la derecha:
SELECT E.Nombre as 'Empleado',D.Nombre as 'Departamento'
FROM Empleados E
RIGHT JOIN Departamentos D
ON E.DepartamentoId = D.Id

Ejecutar
La tabla de la izquierda es Empleados, mientras que Departamentos es la tabla de la derecha.
La tabla asociada al FROM será siempre la tabla LEFT, y la tabla que viene después del JOIN será la tabla RIGHT.
Entonces el resultado mostrará todos los departamentos al menos 1 vez.
Si no hay ningún empleado trabajando en un departamento, se mostrará NULL. Pero el departamento aparecerá de todo modos.
+------------+-----------------+
| Empleado   |  Departamento   |
+------------+-----------------+
| Rafferty   |   Sales         |
| Jones      |   Engineering   |
| Heisenberg |   Engineering   |
| Robinson   |   Clerical      |
| Smith      |   Clerical      |
| NULL       |   Marketing     |
+------------+-----------------+

Cláusula FULL JOIN
FULL JOIN es una mezcla entre LEFT JOIN y RIGHT JOIN ya que se muestra ambas tablas.

En el ejemplo, ocurre lo siguiente:
SELECT E.Nombre as 'Empleado',D.Nombre as 'Departamento'
FROM Empleados E
FULL JOIN Departamentos D
ON E.DepartamentoId = D.Id

Pero todavía no esta implementado desgraciadamente en MySQL, mientras tanto podemos unir LEFT JOIN y RIGHT JOIN para obtener FULL JOIN. Por lo que una manera similar de realizarlo seria de la siguiente forma :
SELECT E.Nombre as 'Empleado',
  D.Nombre as 'Departamento'
  FROM Empleados E
  LEFT JOIN Departamentos D
  ON E.DepartamentoId = D.Id
UNION
SELECT E.Nombre as 'Empleado',
  D.Nombre as 'Departamento'
  FROM Empleados E
  RIGHT JOIN Departamentos D
  ON E.DepartamentoId = D.Id;

Se muestra el empleado "Williams" a pesar que no está asignado a ningún departamento, y se muestra el departamento de "Marketing" a pesar que aún nadie está trabajando allí :
+------------+----------------+
| Empleado   |  Departamento  |
+------------+----------------+
| Rafferty   |  Sales         |
| Jones      |  Engineering   |
| Heisenberg |  Engineering   |
| Robinson   |  Clerical      |
| Smith      |  Clerical      |
| Williams   |  NULL          |
| NULL       |  Marketing     |
+------------+----------------+

Ejecutar
Más variantes
Si prestamos atención a los diagramas de Venn, vamos a notar que es posible formar incluso más combinaciones, al momento de seleccionar datos.
Por ejemplo, tenemos el siguiente caso, conocido como Left Excluding JOIN:

Y de igual manera Right Excluding JOIN:

Estas combinaciones son posibles de lograr si añadimos algunas condiciones a nuestras consultas, haciendo uso de la cláusula WHERE.
Por ejemplo, siguiendo el ejemplo que estamos viendo (donde Empleados es la tabla izquierda y Departamentos la tabla derecha):

*Left Excluding JOIN nos permitirá obtener la lista de empleados que aún no han sido asignados a ningún departamento de trabajo.

*Mientras que Right Excluding JOIN nos mostrará la lista de departamentos que no tienen a ningún trabajador asociado.

Información sacada de :


Q: Agregar Bower a una aplicación ASP NET Empty Estoy creando un proyecto ASP NET MVC 5 Empty, y estoy agregando manualmente mis referencias de JavaScript.
He agregado esta línea:
<script src="./bower_components/angular/angular.min.js"></script>

Ahora mis preguntas son: ¿Cómo se descargan esos paquetes, si no he agregado Bower al proyecto? ¿Cómo lo puedo agregar?

A: Lo que debes hacer es instalar bower, los requisitos son tener instalado node, npm y git.
Una vez instalados los requisitos el comando para instalar bower es el sgte:
npm install -g bower

Luego puedes crear un archivo bower.json mediante el sgte comando:
bower init

Debes de responder las preguntas para crear un archivo bower.json personalizado.
Luego de esto puedes obtener el paquete de angular con el sgte comando:
bower install angular --save

El flag --save incluye la dependencia en tu archivo bower.json recién creado
Además no debes referenciar esos archivos dentro de bower_components directamente por muchos motivos, por ejemplo:

*Esa ruta ha sido definida por bower y podría cambiar en un futuro.

*Esa carpeta no debe ser desplegada ya que contiene muchos archivos posiblemente innecesarios.

Lo que deberías hacer es copiar los archivos que necesitas usando algun task runner como gulp o grunt.

A: Así es como lo hice yo: (para VS2015, sdk 1.0.0-beta6)
Este método NO instala bower de forma global
NOTA: Hecho a partir de este template:

1 - Click derecho sobre el proyecto (en el explorador de soluciones), luego "Nuevo elemento" (o "New item" si el VS esta en ingles)
2 - Agregar NPM Configuration file.

3 - Editar el nuevo archivo "package.json" de modo tal que quede incluya estas 3 dependencias de desarrollo:
{
  "name": "nompre_projecto",
  "version": "0.1.0",
  "private": true,
  "devDependencies": {
    "bower": "1.6.5",
    "grunt": "0.4.5",
    "grunt-bower-task": "0.4.0"
  }
}

4 - Igual que punto 1, pero seleccionando "Grunt Configuration File".
5 - Editar Gruntfile.js
module.exports = function(grunt) {
    grunt.initConfig({
        bower: {
            install: {
                options: {
                    targetDir: "wwwroot/lib",
                    layout: "byComponent",
                    cleanTargetDir: false
                }
            }
        }
    });

    grunt.registerTask("default", [""]);

    grunt.loadNpmTasks("grunt-bower-task");
};

6 - Igual que punto 1, pero seleccionando "Bower Configuration File"
7 - Editar bower.json
{
  "name": "SBCom",
  "license": "Apache-2.0",
  "private": true,
  "dependencies": {
    "angular": "1.4.3",
    "angular-route": "1.4.3",
    "angular-animate": "1.4.3",
    "moment": "2.10.6",
    "lodash": "3.10.1",
    "mocha": "2.2.5"
  }
}

Con las dependencias que tu necesites
8 - Click derecho sobre Grunfile.js y buscas "Task Runner Explorer" (no se como sera en español)

9 - Una vez abierto el "Task Runner Explorer" haces doble click sobre "". En el futuro cuando actualices o agregues un paquete bower, debes hacer lo mismo.

10 - Como en la tarea grunt se indico targetDir: "wwwroot/lib" debes ir ubicar el path correcto en los HTML asi:
<script src="lib/angular/angular.js"></script>
<script src="lib/angular-route/angular-route.js"></script>
<script src="lib/moment/moment.js"></script>


Q: ¿Es std::function equivalente a un puntero? Estaba practicando con lambdas y me encontré con el siguiente código:
auto make_fibo() {
    return [](int n) {
        std::function<int(int)> recurse;

        recurse = [&](int n) {
            return (n <= 2) ? 1 : recurse(n - 1) + recurse(n - 2);
        };

        return recurse(n);
    };
}

Yo no sabia que era function ni como trabajaba después de buscar y leer varios textos por ejemplo el siguiente:

Mi pregunta es si, std::function es similar a lo siguiente por ejemplo:
typedef int (*FredMemFn)(int i);

A: La respuesta es sí. La cuestión es que function<> es capaz de manejar más casos que el de ser un simple puntero a una función. Por ejemplo, puede cubrir también el caso de functor, es decir, el caso de una clase con el operador () sobrecargado. Fíjate en el siguiente código:
#include <iostream>
#include <functional>
using namespace std;

int doble(int x) {
    return x * 2;
}

class Doblador {
public:
    int operator()(int x) {
        return x * 2;
    }
};

int main() {
    Doblador d;
    function<int(int)> f = doble;

    cout << "Doble de 2 = " << f( 2 ) << endl;

    f = d;
    cout << "Doble de 2 = " << f( 2 ) << endl;

    return 0;
}

Tienes el código aquí:
Espero que te resulte útil.

A: std::function es una clase que envuelve a cualquier elemento que pueda ser invocado, por ejemplo:

*Punteros a funciones (lo que se menciona en la pregunta).

*Objetos de una clase que tiene el operador () sobrecargado.

*Expresiones lambda.

*Expresiones bind (std::bind, básicamente un puntero a función con uno o más argumentos predefinidos de antemano).

Fuente: cppreference.com - std::function
Nótese que las funciones "template" no son invocables como tal, solo una instancia en particular de una función template con un tipo ya asociado puede combinarse con un std::function.


Q: ¿Cómo mostrar un mensaje de error más inteligible al comparar fechas de moment.js con Jasmine? Estoy usando moment.js para manejar fechas desde JavaScript y Jasmine para escribir pruebas unitarias. En un momento dado quiero hacer un test que compruebe que dos fechas son iguales, para lo cual hago lo siguiente:
it('properly compares dates', function () {
    var date1 = moment("2000-01-02", "YYYY-MM-DD");
    var date2 = moment("1999-03-04", "YYYY-MM-DD");
    expect(date1).toEqual(date2);
});

Esto funciona como se espera: si las fechas fueran iguales el test pasaría, pero como no lo son, pues no pasa. El problema: el mensaje de error que lanza contiene el objeto completo, del cual es muy difícil extraer los valores comparados:

Expected Moment({ _isAMomentObject: true, _i: '2000-01-02', _f:
  'YYYY-MM-DD', _isUTC: false, _pf: Object({ empty: false, unusedTokens:
  [  ], unusedInput: [  ], overflow: -1, charsLeftOver: 0, nullInput:
  false, invalidMonth: null, invalidFormat: false, userInvalidated:
  false, iso: false }), _locale: Locale({ _ordinalParse:
  /\d{1,2}(th|st|nd|rd)/, ordinal: Function, _abbr: 'en',
  _ordinalParseLenient: /\d{1,2}(th|st|nd|rd)|\d{1,2}/ }), _d: Date(Sun Jan 02 2000 00:00:00 GMT+0100 (Romance Standard Time)) }) to equal
  Moment({ _isAMomentObject: true, _i: '1999-03-04', _f: 'YYYY-MM-DD',
  _isUTC: false, _pf: Object({ empty: false, unusedTokens: [  ], unusedInput: [  ], overflow: -1, charsLeftOver: 0, nullInput: false,
  invalidMonth: null, invalidFormat: false, userInvalidated: false, iso:
  false }), _locale: Locale({ _ordinalParse: /\d{1,2}(th|st|nd|rd)/,
  ordinal: Function, _abbr: 'en', _ordinalParseLenient:
  /\d{1,2}(th|st|nd|rd)|\d{1,2}/ }), _d: Date(Thu Mar 04 1999 00:00:00
  GMT+0100 (Romance Standard Time)) })

Mi pregunta es: ¿hay alguna forma de personalizar los mensajes de error para los tests fallidos en Jasmine (específicamente para moment.js)? No he podido encontrar ninguna solución en la documentación oficial.

A: He acabado implementando un custom matcher que registro antes de los tests:
beforeEach(function() {
    var customMatchers = {
        toBeSameDate: function() {
            return {
                compare: function(actual, expected) {
                    var result = {};
                    result.pass = actual.isSame(expected);
                    result.message =
                        "Expected " + actual.format("YYYY-MM-DD") +
                        " to equal " + expected.format("YYYY-MM-DD");
                    return result;
                }
            }
        }
    };
    jasmine.addMatchers(customMatchers);
});

Así pues, simplemente sustituyendo .toEqual por .toBeSameDate en el test, el mensaje de error cambia a:

Expected 2000-01-02 to equal 1999-03-04

Esto además tiene la ventaja de que en el futuro puedo extender el matcher si es necesario, por ejemplo para ignorar la hora.

A: Puedes hacerlo comparando la fecha formateada, utilizando moment.format():
var actual   = moment('2015-11-06'),
    esperado = moment('1998-04-09');

expect(actual.format()).toBe(esperado.format());

Expected '2015-11-06T00:00:00-03:00' to be '1998-04-09T00:00:00-03:00'.

Esto de te permite verificar una fecha y si la prueba falla, ver un detalle compacto y completo.


Q: ¿Cómo hacer una petición HTTP POST con Ruby? Necesito hacer una petición POST a una API de Google a la URL:

Me gustaría hacerlo sin usar una gema especifica para esa API de GOOGLE sino de la forma más cercana a lo que traiga Ruby 2.2.0 por defecto, de ser posible.

A: Me salió, haciendo lo siguiente, pero no sé si es una buena práctica:
require 'uri'
require 'net/http'
require 'openssl'

recaptcha_url = ""
remoteip = request.remote_ip
uri = URI(recaptcha_url)
options = {
    :secret => ENV["SECRET_KEY_CAPTCHA"],
    :remoteip => request.env["REMOTE_ADDR"],
    :response => user_response
}
response = Net::HTTP.post_form(URI.parse(recaptcha_url), options)
puts("Body: #{response.body}")

#then parse the json response in the above 'response' variable and check whether
#the API returns a success or failure and return true or false depending on it
#logger.info "------status ==> #{response.body}"
hash = JSON.parse(response.body)
hash["success"] == true ? true : false

A: Aunque al final termine usando cURL, este es un script utilizado para hacer un post en Ruby, recuerda configurar tus credenciales y el tipo de contenido:
  full_url = ""
    uri = URI.parse(full_url)
    http = Net::HTTP.new(uri.host, uri.port)
    http.use_ssl = true
    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
    headers = {'Content-Type' => "application/json", 'Accept-Encoding'=> "gzip,deflate",'Accept' => "application/json" }
    request = Net::HTTP::Post.new(uri.request_uri, headers)
    request.body = {'credentials' => {'username' => 'jorgesys', 'key' => 'bombonica'}}
    response = http.request(request)

A: Puedes usar la nice_http gem que te simplificará el proceso:

require 'nice_htpp'

http = NiceHttp.new('')

req = {
  path: '/recaptcha/api/siteverify',
  data: {
    secret: 'ACA_LA_CLAVE',
    remoteip: 'IP',
    response: 'KEY_RESPONSE'
  }
}

resp = http.post req


Q: Manipular los checkbox de un grid con Knockoutjs y KendoUI Quisiera saber cómo detectar el cambio en la propiedad de un objeto observable en una grilla al seleccionar un checkbox con knockoutjs.
El código que actualmente  tengo es de esta forma.


Q: ¿Cómo saber si un archivo regular no existe en bash? Supongamos que estoy en un directorio y sé que un archivo archivo existe:
if [ -f "archivo" ]; then
    echo "archivo existe"
fi

¿Hay alguna manera de comprobar si el archivo no existe sin tener que utilizar el else de este condicional?

A: Extraído de la pregunta hermana How do I tell if a regular file does not exist in bash?.
¡Sí! Solo tienes que utilizar la negación ! en el condicional:
if [ ! -f "archivo" ]; then
    echo "archivo no existe"
fi

O de una forma más concisa:
[ ! -f "archivo" ] && echo "archivo regular no existe"

Nótese que man test indica que la opción -f:
-f FILE
     FILE exists and is a regular file

Por lo que la negación de esto simplemente quiere decir que lo indicado no es un archivo regular. Puede no ser nada o puede ser un directorio, etc.

A: Se puede utilizar la negación ! antes del -f
if [ ! -f "$archivo" ]; then
    echo "archivo inexistente"
fi

o antes del [
if ! [ -f "$archivo" ]; then
    echo "archivo inexistente"
fi

También se puede utilizar -e de esta forma
if [ ! -e "$archivo" ]; then
   echo "archivo inexistente"
fi

A: Este es el script que uso para revisar si un archivo existe:
if [ ! -f "/miFolder/miArchivo.txt" ]; then
    echo "El archivo no existe"
fi

la opción -f es negada para determinar no existe el archivo.


Q: ¿Cómo comprobar si una lista no contiene elementos repetidos? C# Tengo una lista:
List<byte> unaLista = new List<byte> { 1,4,3,6,1 };

¿Cómo puedo comprobar que no contenga elementos repetidos, es decir, está Unqiue o no?

A: Usa DISTINCT()
bool estaUnique = unaLista.Distinct().Count() == unaLista.Count();


Q: Cierre de sesión con Hibernate y Spring Quiero saber ¿Cómo cerrar la sesión hibernate, si estoy manejando la transacción con Spring 4.x?.
Modelo
import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
@Entity
@Table(name="EGRESOS")
public class Egreso {
    @Id
    @GeneratedValue
    @Column(name="id")
    private Long id;
    @Temporal (TemporalType.DATE)
    @Column(name="fecha")
    private Date fecha;
    @Column(name="importe")
    private Double importe;
    @Column(name="detalle")
    private String detalle;

    public Egreso() {
        // TODO Auto-generated constructor stub
    }

//all getters and setters

Persistencia
public abstract class CustomHibernateSupport<T> extends HibernateDaoSupport implements IGenericDAO<T> {
    private Class<T> persistentClass;
    @Autowired
    private SessionFactory sessionFactory;

    @SuppressWarnings({ "unchecked", "deprecation" })
    public CustomHibernateSupport() {
        this.persistentClass = (Class<T>) ((ParameterizedType) getClass()
                .getGenericSuperclass()).getActualTypeArguments()[0];
        this.sessionFactory = new Configuration().configure() // configures
                                                                // settings from
                                                                // hibernate.cfg.xml
        .buildSessionFactory();
    }

    @PostConstruct
    public void init(){
        setSessionFactory(sessionFactory);
        getHibernateTemplate().setCacheQueries(true);
    }

    public Class<T> getPersistentClass() {
        return persistentClass;
    }

    public void setPersistentClass(Class<T> persistentClass) {
        this.persistentClass = persistentClass;
    }

    public void insert(T entity) {
        getHibernateTemplate().save(entity);
    }

    public void delete(T entity) {
        getHibernateTemplate().delete(entity);
    }

    public void update(T entity){
        getHibernateTemplate().update(entity);
    }

    @SuppressWarnings("unchecked")
    public List<T> findAll() {
        Session session = getSessionFactory().openSession();
        Criteria cr = session.createCriteria(getPersistentClass());

        return cr.list();
    }

    @SuppressWarnings("unchecked")
    public T findById(Long id) {
        Session session = getSessionFactory().openSession();
        Criteria criteria= session.createCriteria(getPersistentClass());
                 criteria.add(Restrictions.eq("id",id));
        return (T) criteria.uniqueResult();
    }

    @SuppressWarnings("unchecked")
    public List<T> findByDate(Date date) {
        System.out.println(date);
        Session session = getSessionFactory().openSession();
        Criteria criteria= session.createCriteria(getPersistentClass());
                 criteria.add(Restrictions.eq("fecha",date));

        return  criteria.list();
    }
}

Servicio
@Transactional(readOnly=false)
public boolean cargarGasto(GastosRequestDTO nuevo){
    Egreso e = new Egreso();
    try{
            e.setDetalle(nuevo.getDetalle());
            e.setFecha(nuevo.getFecha());
            e.setImporte(nuevo.getImporte());
            egreso.insert(e);
            log.info("se inserto correctamente el nuevo gasto ID: "+ e.getId());
            return true;
    }
    catch(Exception ex){
        log.error(Throwables.getStackTraceAsString(ex));
        log.error("No se pudo insertar gasto ");
    }
    return false;
}

Controlador
public void cargarGasto() {
        GastosRequestDTO nuevoGasto = new GastosRequestDTO();
        nuevoGasto.setFecha(fecha);
        nuevoGasto.setDetalle(descripcion);
        nuevoGasto.setImporte(importe);
        if (hotel.cargarGastos(nuevoGasto)) {
            obtenerBalance();
            setImporte(null);
            setDescripcion(null);

    }
}

ApplicattionContex.xml

<>
< base-package="ar.com.as.hotel"/>
<bean id="recordDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
    lazy-init="true" destroy-method="close">

    <property name="driverClass" value="org.gjt.mm.mysql.Driver" />

    <!-- CHANGE THE DATABASE CONNECTION-->
    <property name="jdbcUrl" value=">
    <property name="user" value="********" />
    <property name="password" value="********" />
    <!-- ***************************************** -->

    <property name="minPoolSize" value="1" />
    <property name="maxPoolSize" value="100" />
    <property name="initialPoolSize" value="5" />
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
    <property name="configLocation">
        <value>./WEB-INF/classes/hibernate.cfg.xml</value>
    </property>
    <property name="dataSource">
        <ref bean="recordDataSource" />
    </property>
</bean>
<bean id="transactionManager"
    class="org.springframework.orm.hibernate4.HibernateTransactionManager">
    <property name="sessionFactory">
        <ref local="sessionFactory" />
    </property>
</bean>
< transaction-manager="transactionManager" />

Hibernate.xml
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration SYSTEM
"">
<hibernate-configuration>
    <session-factory>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url"></property>
        <property name="connection.username">******</property>
        <property name="connection.password">******</property>
        <property name="hbm2ddl.auto">update</property>
        <property name="connection.autocommit">false</property>

<!--        <mapping resource="Cliente.hbm.xml" /> -->

        <mapping class="ar.com.as.hotel.modelo.Ingreso" ></mapping>
        <mapping class="ar.com.as.hotel.modelo.Precio"></mapping>
        <mapping class="ar.com.as.hotel.modelo.Habitacion"></mapping>
        <mapping class="ar.com.as.hotel.modelo.Temporada"></mapping>
        <mapping class="ar.com.as.hotel.modelo.Egreso"></mapping>

        <!-- List of XML mapping files -->

    </session-factory>
</hibernate-configuration>

A: La sesión se va a cerrar sola. Spring Transaction la va a manejar por ti. Solo asegúrate que los métodos que necesiten conectividad a la base de datos y utilicen Hibernate estén anotados correctamente con @Transactional o que estén configurados vía xml.

A: Como lo veo es mas que nada un problema de tu configuración, realmente trata de no mezclar peras con manzanas.
Te puedo decri que el archivo Hibernate.xml esta de mas ya que ahora tienes un archivo de configuración con Spring el cual te sirve para lo mismo.
Lo mejor es que le digas a Spring que tus entidades se encuentran en tal paquete y te cree la unidad de persistencia que necesitas, asi ya no tendras que estar agregando cada una de las entidades que generes al archivo.
Este es un ejemplo.

<bean id="entityManagerFactory"
    class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="persistenceUnitName" value="persistenceUnit" />
    <property name="packagesToScan">
        <list>
            <value>com.todo.model</value>
        </list>
    </property>
    <property name="dataSource" ref="dataSource" />
    <property name="jpaVendorAdapter">
        <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
            <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
            <property name="showSql" value="true" />
        </bean>
    </property>
    <property name="jpaProperties">
        <props>
            <prop key="hibernate.hbm2ddl.auto">update</prop>
        </props>
    </property>
</bean>

<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
    <property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>

< transaction-manager="transactionManager" />

< />

< base-package="com.todo" />

Aquí una pregunta para evitar el archivo persistence.xml que es el equivalente a tu archivo de Hibernate.

Y aquí un proyecto con la configuración ya hecha


Q: Inicialización de variables en Python usando una función separada de main() Para inicializar algunas variables en un programa escrito en Python (de forma estructurada, sin usar programación orientada a objetos), quiero utilizar una función denominada inicializacion(), a la cual se invoca desde una función main(). El problema es el ámbito de estas variables, ya que si les doy su valor inicial en la función inicializacion(), al tratar de usarlas en la función main() se va a generar un error porque allí no existen. Por ejemplo:
import serial

def inicializacion():
    puerto = '/dev/ttyACM0'
    baudRate = 115200
    buffer = ''
    ser = serial.Serial(puerto, baudRate, timeout=1)

def main():
    inicializacion()
    buffer = buffer + leerDatos(ser)

¿Qué alternativas hay para evitar el uso de "global" en la función de inicialización? ¿Es posible implementar alguna solución sin tener que pasar las variables como argumentos y sin tener que devolverlas en el "return"?

A: Pues, no creo que esto sea posible sin recurrir a la altamante no recomendada global. El caso específico que muestras aplica perfectamente en la Programación Orientada a Objetos, sería bueno que expliques la razón por la cual estás tratando de evitarla:
import serial

class Clase():
    def __init__(self, puerto, baud_rate, buffer) # inicializacion()
        self.puerto = puerto
        self.baud_rate = baud_rate
        self.buffer = buffer
        self.serial = serial.Serial(puerto, baudRate, timeout=1)

    def leer_datos(self):
        # Tu código

Si estas intentando usar los parámetros de configuración, podrías crear un archivo específico el cual será importado a demanda:
settings.py
puerto = '/dev/ttyACM0'
baudRate = 115200
buffer = ''

main.py
import serial
import settings

def main():
    ser = serial.Serial(settings.puerto, settings.baudRate, timeout=1)
    buffer = settings.buffer + leerDatos(ser)

Otra opción es la mencionada por @Carlangueitor en la cual tu configuración la mueves a un archivo .env dentro de tu proyecto y así evitas exponer la configuración en uno de los archivos. Puedes usar dotenv.

A: Creo que podrías utilizar un diccionario. Puedes pasar el diccionario, así como devolverlo, manteniendo los cambios que realices en su interior. Fíjate en el siguiente código.
def inicializacion():
    toret = {}
    toret["puerto"] = '/dev/ttyACM0'
    toret["baudRate"] = 115200
    toret["buffer"] = ''

    return toret

def main():
    datos = inicializacion()
    datos["buffer"] = "hola"
    print(datos["buffer"])
    print(datos)

main()

Tienes el código aquí:
Espero que te resulte útil.

A: La forma más sencilla y pythonica, adaptando tu propio código:
import serial

def inicializacion(puerto='/dev/ttyACM0', baudRate=115200):
    ser = serial.Serial(puerto, baudRate, timeout=1)
    return ser

def main():
    ser = inicializacion()
    buffer=''
    buffer = buffer + leerDatos(ser)

    # El puerto se ha de cerrar para evitar fugas de memoria..
    ser.close()

Lo ideal sería cambiarle el nombre de inicializacion a otro más expresivo y explícito como p.ej.: inicializacion_puerto_serie
Al pasar los valores a la función inicializacion como parámetros por defecto se puede reutilizar el código con otro puerto u otro baud_rate diferente.
No te olvides nunca cuando abras un fichero o un puerto serie (que para el sistema es lo mismo) de cerrarlo correctamente para evitar fugas de memoria.

A: Te propongo lo siguiente:
import serial

puerto='/dev/ttyACM0'
baudRate=115200

def main():
    buffer=''
    serial.Serial(puerto, baudRate, timeout=1)
    buffer=buffer+leerDatos(str)


Q: Preservar Actividad después de presionar el botón "Atrás" Estoy trabajando una aplicación con android la cual realiza una autenticación a través de una actividad "A" (LoginActivity), este instancia la actividad "B" (LoginTask) que hereda de AsyncTask para realizar dicho proceso, una vez realizada la autenticación se instancia a la actividad "C" (PrincipalActivity), siendo algo como esto A -> B -> C.
Ubicado en la actividad "C", presiono el botón "Atras" y este me "saca" de la actividad principal y me ubica en la actividad "A", decir, me regresa a la pantalla de logueo. Aquí mi código:
LoginActivity
public class LoginActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);
        initUI();
    }

    private void initUI() {
        Typeface font = Typeface.createFromAsset(getApplicationContext().getAssets(),"fonts/NotoSans-Regular.ttf");

        final EditText txtUser = (EditText)findViewById(R.id.txtUser);
        txtUser.setTypeface(font);
        final EditText txtPass = (EditText)findViewById(R.id.txtPass);
        txtPass.setTypeface(font);
        Button btnAccess = (Button) findViewById(R.id.btnAccess);
        btnAccess.setTypeface(font);

        btnAccess.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Login loginBean = new Login();
                String user = txtUser.getText().toString().trim();
                String pass = txtPass.getText().toString().trim();

                if (!user.equals("")) {
                    if(!pass.equals("")) {
                        loginBean.setUser(user.toUpperCase());
                        loginBean.setPass(pass);
                    } else {
                        txtPass.setError(getString(R.string.err_pass));
                        return;
                    }
                } else {
                    txtUser.setError(getString(R.string.err_user));
                    return;
                }

                LoginTask loginTask = new LoginTask(LoginActivity.this,loginBean);
                loginTask.execute();
            }
        });
    }
}

LoginTask
public class LoginTask extends AsyncTask {
    private ProgressDialog progressDialog;
    private Context context;
    private Resources resources;
    private Login loginParams;
    private String msgAccess;

    public LoginTask(Context context, Login loginParams) {
        this.context = context;
        this.resources = context.getResources();
        this.loginParams = loginParams;
    }

    protected void onPreExecute() {
        progressDialog = new ProgressDialog(context);
        progressDialog.setMessage(resources.getString(R.string.msg_access));
        progressDialog.setCancelable(true);
        progressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
        progressDialog.show();
    }

    @Override
    protected String doInBackground(Object[] objects) {
        //Autenticación
        return msgAccess;
    }

    protected void onPostExecute(Object o) {
        if (msgAccess != null) {
            if (msgAccess.equals("OK")) {
               Intent intent = new Intent(context, PrincipalActivity.class);
               intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
               context.startActivity(intent);
               ((Activity)context).finish();
            } else {
                Toast.makeText(context, msgAccess, Toast.LENGTH_LONG).show();
            }
        } else {
            Toast.makeText(context, R.string.err_msg_null, Toast.LENGTH_LONG).show();
        }

        if (progressDialog.isShowing()) {
            progressDialog.dismiss();
        }
    }
}

Entonces, lo que habia pensado era realizar algun tipo de validación en el evento onBackPressed() de mi clase principal para que cuando presione el botón "Atras" no me regrese a "A", sino, me mantenga en la actividad principal "C":
@Override
public void onBackPressed() {
    if (LoginPersistence.getStatus() > 0 && !LoginPersistence.getToken().equals("")) {
 //Agregar aqui la validación
    }
}

Para ser mas explicito, lo que indico es que cuando estoy en mi actividad principal "C" y presiono el botón "Atrás", este me regresa a la actividad "A", es decir, para ingresar nuevamente usuario y password, cuando no debería hacerlo. Al presionar el botón "Atrás", debería "minimizar" mi aplicación y cuando vuelva a ingresar debería mantenerla en la actividad principal. Es lo que hago cuando presiono el botón "Home", me minimiza la aplicación y cuando vuelvo, me carga donde me quedé y esto lo logro con intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);.
Espero haberme explicado. Gracias.

A: En base a tu pregunta, deseas regresar a la "actividad B",  LoginTask pero recuerda que esta en realidad no es una Actividad es un AsyncTask.

*"A" (LoginActivity)

*"B" (LoginTask)

*"C" (PrincipalActivity)

LoginTask es un Thread que en realidad realiza un Intent para abrir la actividad PrincipalActivity.
 Intent intent = new Intent(context, PrincipalActivity.class);

Si deseas regresar a "B" LoginTask, entonces esta clase debe extender de Activity y dentro de esta clase un instancia el Asynctask con la misma funcionalidad.

A: LoginTask no es una actividad, es una tarea asíncrona, y esta puedes declararla dentro de LoginActivity.
Después de verificar la autenticación en MainActivity inicia LoginActivity así:
    if(!isAuthenticated){
        Intent intent = new Intent(this, LoginActivity.class);
        intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
        startActivity(intent);
        MainActivity.this.finish();
    }

Lo que hicimos aquí fue finalizar la MainActivity después de lanzar LoginActivity, entonces si la autenticación no fue correcta o no se realizó nada entonces cuando presiones atrás se saldrá de la aplicación sin volver a la actividad principal.
Después de haberte autenticado correctamente solo debes iniciar de nuevo la actividad principal "MainActivity" entonces la inicias de esta manera aplicando el mismo principio de arriba:
Intent intent = new Intent(LoginActivity.this, MainActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(intent)
LoginActivity.this.finish();

Con esto debería ser suficiente para regresar de LoginActivity a MainActivity después de iniciar sesión y cuando presiones atrás se terminará la aplicación.

A: En tu AndroidManifest.xml debes incorporar "
    <activity
        "
        "
        ">
        <intent-filter>
            <action " />

            <category " />
        </intent-filter>
    </activity>

y esa actividad no será almacenada en el historial de actividades.

A: Utiliza FLAG_ACTIVITY_CLEAR_TASK, en lugar de FLAG_ACTIVITY_CLEAR_TOP cuando inicias tu actividad:
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
context.startActivity(intent);

Eso a mi me ha funcionado, cuando presiones "back" debe simplemente cerrar tu aplicación.
Espero te funcione.

A: Lo que responde Elenasys es correcto. LoginTask es una AsyncTask, con lo cual no es una Activity. No puedes "volver a ella".
Si quieres entender algo más sobre el estado de tu stack de activities, puedes correr el siguiente comando de adb:
adb shell dumpsys activities

Ahí podrás ver cómo están tus actividades y comprender qué pasará cuando pulsas "back".


Q: ¿Cómo puedo deshacer el último commit en Git? Hice un commit e inmediatamente después noté que commiteé cambios que no quiero pushear al remote.
¿Hay alguna manera de deshacer el mismo manteniendo esos cambios en mi copia local para volver a commitearlos correctamente?

A: Si quieres mantener los cambios:
git reset [--mixed] HEAD~1

Si además no quieres cargarte el commit (sólo mover el head al anterior):
git reset --soft HEAD~1

Y si no quieres mantenerlos (y volver al estado del commit anterior, en la práctica, destruir el último commit completamente como si nunca hubiera existido):
git reset --hard HEAD~1

A: El comando es git reset <commit>
Para deshacer específicamente el último commit puedes usar HEAD~1
Por ejemplo para volver al commit anterior puedes usar el sgte comando:
git reset HEAD~1

El parámetro --mixed permite mantener los cambios en el working tree para que puedan ser modificados luego, sin embargo al ser el modo por defecto no es necesario.
En este caso me parece la opción más adecuada ya que quieres corregir el commit así que necesitas revertir el index para corregir los cambios.
Algunos de los parámetros opcionales son:

*

*--soft no modifica ni el working tree ni el index. Solo cambia el HEAD al commit indicado.

*--mixed revierte el index pero no el working tree de modo que se mantienen los cambios listos para ser modificados y posiblemente commiteados de nuevo. Esta es la opción por defecto.

*--hard Revierte el index y el working tree de modo que los cambios se pierden totalmente.

Puedes revisar la sintaxis completa en git-reset Documentation

A: $ git reset --soft HEAD~  o $ git reset --soft HEAD~1       #1
// Cambios necesarios //                                    #2
$ git add ...                                               #3
$ git commit ...                                            #4

Simplemente haces un reset soft, con lo que te quedas con los cambios en local pero deshaces el commit, después haces lo que quieras y vuelves a hacer el commit como querías la primera vez.

A:
¿Cómo puedo deshacer el último commit en Git?

Esta es la forma correcta de realizarlo:
$ git reset --soft HEAD~

muy importante, como lo cita otro usuario, esta opción aplica cuando necesitas mantener los cambios.


Q: Solicitudes ajax en Laravel Este es el código ejemplo de un controlador y el manejo normal (no AJAX) de un Request o solicitud.
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;

use Illuminate\Routing\Controller;

class UserController extends Controller
{
    /**
     * Store a new user.
     *
     * @param  Request  $request
     * @return Response
     */
    public function store(Request $request)
    {
        $name = $request->input('name');
        //
    }
}

¿Qué debo hacer para que funcione también para solicitudes AJAX en la función store() ?
Si creo otra función storeAjax() , puedo incluirla en routes.php (con una nueva ruta asignada) y funciona, pero no es una buena práctica, pues tengo 2 rutas y debe ser la misma para ambas solicitudes.

A: Quizás esto te pueda ayudar:
if($request->ajax()){ }//procesa la peticion ajax
else{return $view;} //retornas por ejemplo,una vista

En cuanto al Routes.php, no hay necesidad de modificar, lo que haces en tu JS es un request de tipo GET:
$.ajax(type: 'GET', ...)

Y procesas la petición, espero te ayude.

A: Utiliza el siguiente ejemplo para crear una función del controlador más potente.

*Controlamos si la petición viene de una petición AJAX o no, y devolvemos una respuesta en JSON o un Redirect dependiendo del caso

*Uso de Try/Catch para capturar errores

*Uso de Log para el registro de errores

-
public function store()
{
    $data = [
        'name'  =>  Input::get('name'),
    ];

    try
    {
        $result = $this->repository->create($data);
    }
    catch (Illuminate\Database\QueryException $e)
    {
        Log::error("YourController@store: register your error", array('created_by' => Auth::user()->id, 'message' => $e->getMessage());

        if (!Request::ajax())
        {
            return Redirect::back()
                ->with('type_message', "danger")
                ->with('message', trans('web.error'))
        }
        else
        {
            return "{\"result\":\"ko\",\"error\":\"$e->getMessage()\"}";
        }
    }

    if ($result)
    {
        if (!Request::ajax())
        {
            Log::info("YourController@store: Created OK", array('created_by' => Auth::user()->id, 'result' => $result->toArray()));

            return Redirect::back()
                ->with('type_message', "success")
                ->with('message', trans("web.created_ok"));
        }
        else
        {
            return "{\"result\":\"ok\",\"id\":\"$result->id\",\"name\":\"$result->name \"}";
        }
    }
    else
    {
        return "{\"result\":\"ko\",\"error\":\"Hubo un error guardando\"}";
    }
}

Ejemplo de petición AJAX:
$.ajax({
        url: "{{ route('my_route')}}",
        data: "name="+name+"&_token={{ csrf_token()}}",
        dataType: "json",
        method: "POST",
        success: function(result)
        {
            if (result['result'] == 'ok')
            {

            }
            else
            {

            }
        },
        fail: function(){
        },
        beforeSend: function(){
        }
    });
});

Crea una ruta que apunte al metodo Store de tu controlador, que te servirá tanto para peticiones desde un formulario como para peticiones AJAX:
Route::post('/my_route', array('as' => 'my_route', 'uses' => 'YourController@store'));

A: No es necesario implementar otro método.
Si no te funciona puede ser debido a que Laravel 5 incluye una validación del token CSRF, por motivos de seguridad, en todas las peticiones POST, PUT y DELETE. Debes incluir este token en la petición.
Puedes ver diferentes métodos para incluir este token en la documentación oficial:

A: Puedes probar con esto
public function store(Request $request)
{
    if($request->ajax())
    {
        $name = $request->input('name');
        Response->json($name);
    }
}


Q: ¿Cómo revertir un commit, si ya subí los cambios al origen? Acabo de darme cuenta que hice un commit que incluye una contraseña. El problema es que ya subí los cambios al repositorio origen.
¿Cómo puedo repararlo sin perder los cambios que hice y sin que quede la contraseña en el historial del repositorio?

A: Tienes que hacer de nuevo el comit, para eso puedes ver cómo acá, luego tienes que hacer push forzando tu versión:
git push -f origin master

Si alguien más ya hizo pull de esos cambios puedes generarle problemas, pero si solo estás trabajando tu con eso, es seguro.

A: Podrías usar git rebase, para eliminar el ultimo commit.
git rebase -i HEAD~1

Debes comentar la linea de código correspondiente al commit, guardar y salir del editor.
Posteriormente ejecutar
git push -f origin master

A: Para esto debes:
1) Ubica el commit del servidor. Puedes obtener los últimos 10 commits asi:
git log -10 --pretty="%H"

Eso te muestra los hash de los commits
30ace57438659c6a715db441ffc6751f385db667
484121a5ed21e8b842ffe61783fde059103185b3
996ee5f0aabd18d14a73e0181780dcc9191337f4
2b0ea751d69c84b909b3011ba5de865125d209b2

2) Ubica el punto deseado y retorna al commit deseado
git reset --hard 484121a5ed21e8b842ffe61783fde059103185b3
HEAD is now at 484121a

3) Envia los cambios al servidor de repositorio
git push --force

Y listo. Te sirve para regresar cualquier commit.

A: Hay que eliminar los commits de tu repositorio local y luego forzar que ese sea el último estado con la opción -f
Por ejemplo para eliminar 10 commits
git reset --hard HEAD~10

y luego forzar que ese sea el estado en origin
git push -f origin master

Más sobre como eliminar commits del historial local:
¿Cómo puedo deshacer el último commit en Git?

A: Elimina el commit en el repositorio local pero no guarda los cambios realizados:
git reset HEAD^ --hard

Elimina el commit en el repositorio local y guarda los cambios realizados:
git reset HEAD^ --soft

Posteriormente se puede hacer push de manera forzada al repositorio remoto.
git push -f origin master


Q: ¿Cómo imprimir la n-ésima línea de un archivo? Supongamos que tengo un archivo archivo con muchas líneas, pero solo quiero imprimir una en concreto, digamos la número n.
¿Cómo puedo conseguirlo utilizando herramientas que estén en un sistema estándar Linux? La opción head XX archivo | tail -N me parece poco práctica.

A: Fácil de escribir:
sed -n 123456p

Más rápido, especialmente si la línea no está cerca del final:
sed '123456q; d'

Un poco más rápido, al menos si el archivo es grande (benchmarks):
tail -n +123457 | head -n 1

head ... | tail ... es mucho más lento porque las primeras 123465 líneas pasan por el tubo.

A: Puedes hacerlo usando el comando sed (Stream Editor):
sed 'LINEAq;d' file

Ejemplo:
$ cat hello.go
package main

import (
    "fmt"
)

func main() {
    fmt.Printf("hello, world\n")
}

Imprimir la primera línea:
$ sed '1q;d' hello.go
package main}

Imprimir la séptima línea:
$ sed '7q;d' hello.go
func main() {

Para mayor información sobre sed, puedes visitar la documentación oficial de GNU.

A: Se me ocurren varias opciones.
Con awk podemos decir:
awk 'NR==n' archivo

y si el número está contenido en una variable $numero, podemos decir:
awk -v linea="$numero" 'NR==linea' archivo

Como NR se refiere a la línea que se está leyendo en un momento dado, solo debemos comparar su valor con el de la variable que le asignamos a través de -v linea="n". Por ejemplo, -v linea=5.
Si resulta que el archivo es muy, muy grande siempre podemos salir una vez se haya imprimido la línea para no seguir leyéndolo innecesariamente:
awk 'NR==linea {print; exit}' archivo

Si preferimos usar sed, podemos decir:
sed -n 'Np' archivo

Y para archivos grandes:
sed -n 'N{p;q;}' archivo

Esto imprimirá la línea numero N y a continuación detendrá la ejecución.
Si el valor está en una variable, debemos usar dobles comillas para que el valor se expanda y ${n} para que se entienda que el nombre de la variable es $n y no $np:
sed -n "${n}p" archivo

A: head y pipe con tail serían lentos para un archivo muy grande. Yo recomendaría  usar sed así:
sed 'NUMq;d' archivo

Donde NUMes el número de línea que quieres imprimir.
Fuente


Q: Validar un email en JavaScript que acepte todos los caracteres latinos Pregunta
¿Cómo validar un e-mail que acepte todos los caracteres latinos?

*Por caracteres latinos me refiero a letras acentuadas, ñ, ç, y todas las usadas por idiomas como español, portugués, italiano... latinos.

Contexto

*El objetivo es mostrar un icono al lado del texto a medida que el usuario va tipeando su dirección de mail.

*No me interesa aceptar todos los casos válidos. Fue una decisión de diseño abarcar sólo los mails más frecuentes. Es decir, letras (incluyendo acentos y similares) y los símbolos ._%+-.

*Puedo usar código de otras fuentes, siempre y cuando sean populares (ej: jQuery).

Código

document.getElementById('email').addEventListener('input', function() {
    campo = event.target;
    valido = document.getElementById('emailOK');

    emailRegex = /^[-\w.%+]{1,64}@(?:[A-Z0-9-]{1,63}\.){1,125}[A-Z]{2,63}$/i;
    //Se muestra un texto a modo de ejemplo, luego va a ser un icono
    if (emailRegex.test(campo.value)) {
      valido.innerText = "válido";
    } else {
      valido.innerText = "incorrecto";
    }
});

    Email:
    <input id="email">

Casos
Estoy usando el regex
/^[-\w.%+]{1,64}@(?:[A-Z0-9-]{1,63}\.){1,125}[A-Z]{2,63}$/i

Que funciona perfecto en casos como

Pero falla con acentos y otras letras latinas
germá
yo@mi-compañía.com
estaçã

A: Con esta expresión regular puedes validar cualquier dirección de correo elecrónico que contenga caracteres Unicode:
/^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i

Si lo pruebas en una consola de JavaScript:
> emailRegex.test("");
< true
> emailRegex.test("germá");
< true

Fuente

A partir de ahí, y como muy bien has mencionado, una expresión que se ajusta más a tus necesidades sería la siguiente:
/^(?:[^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*|"[^\n"]+")@(?:[^<>()[\].,;:\s@"]+\.)+[^<>()[\]\.,;:\s@"]{2,63}$/i

A: Existen ciertas restricciones para emails pero puedo comentar que regularmente deben basarse en estas reglas:

*Mayúsculas y minúsculas del alfabeto ingles.

*Números de 0 al 9

*puede contener punto pero no al inicio o repetirse.

*puede usar los caracteres:  !#$%&'*+-/=?^_`{|}~

Existen restricciones con ciertos tipos de email por ejemplo si contienen:

*Alfabeto griego.

*Caracteres cirílicos.

*Caracteres japoneses.

*Alfabeto latín con diacríticos.

ejemplos no aceptados como direcciones validas de email:
червь.ca®

josé.patroñ

Ver más :

Imagino un email con caracteres cirilicos, peor aún si lo que quieres es almacenar esos datos en una BD, que tipo de SQL collation utilizar!
Pero bueno la pregunta se refiere a como validar ese tipo de emails, este es un script que ayudaría con la tarea:
function validarEmail(valor) {
  if (/^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i.test(valor)){
   alert("La dirección de email " + valor + " es correcta!.");
  } else {
   alert("La dirección de email es incorrecta!.");
  }
}

por ejemplo:
validarEmail("jorgé");

El script te mostraría que la dirección email es correcta.

*Actualización:

Actualmente ya es posible usar caracteres internacionales en nombres de dominio y direcciones de correo electrónico.
Las direcciones de correo electrónico tradicionales están limitadas a los caracteres del alfabeto inglés y algunos otros caracteres especiales. Las siguientes son direcciones de correo electrónico tradicionales válidas:
                                  (English, ASCII)
                              (English, ASCII)
  user+mailbox/department=   (English, ASCII)
  !#$%&'*+-/=?^_`.{|}~@example.com               (English, ASCII)
  "Abc@def"@example.com                          (English, ASCII)
  "Fred Bloggs"@example.com                      (English, ASCII)
  "Joe.\\Blow"@example.com                       (English, ASCII)

El correo electrónico internacional, por el contrario, utiliza caracteres Unicode codificados como UTF-8, lo que permite codificar el texto de las direcciones en la mayoría de los sistemas de escritura del mundo.
Las siguientes son todas las direcciones de correo electrónico internacionales válidas:
  用户@例子.广告                   (Chinese, Unicode)
  अजय@डाटा.भारत                    (Hindi, Unicode)
  квіточка@пошта.укр             (Ukrainian, Unicode)
  θσερ@εχαμπλε.ψομ               (Greek, Unicode)
  Dörte@Sörensen.example.com     (German, Unicode)
  аджай@экзампл.рус              (Russian, Unicode)

A: He encontrado un artículo aquí (en Inglés) que habla de algunas declaraciones diferentes expresiones regulares que pueden verificar direcciones de correo electrónico basados en el estándar RFC. Hay muchas declaraciones de expresiones regulares recomendada diferentes y no hay un único todo-en-una solución. Pero esta expresión regular es probablemente el que me iría con, añadiendo caracteres acentuados a la lista de caracteres válidos también.
\A[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\z

A:
¿Cómo validar un email que acepte todos los caracteres latinos?

La única forma 100% segura de verificar si un email es valido es enviando uno. Si el usuario escribio el correo mal, ellos simplemente reintentaran.
Según RFC 5322,  es un email "valido", pero,
¿alguien lo va a recibir? ¿Existe un servidor detras del dominio que acepte correos? Esas son las preocupaciones que deberias tener. Lo que seas que estas haciendo, una lista de distribución, registro, etc. debe de enviar un correo de confirmación para validarlo. La implementacion dependera del stack que uses (C#, PHP, Java?) y hací tendrás correos validos que alguien recibe.
Puedes implementar algo en el lado del cliente que al menos diga "este es una direción de correo electronico", pero no debería de ser tu herramienta de "validación", solo trata de que el usuario se de cuenta de que lo que escribió es #($^%#$@^(#$^.com. Si el cliente utiliza un navegador moderno, puedes utilizar <input type="email"> en tu formulario, esto eliminará la necesidad de mantener el regex.

A: Simplemente señalar que, de acuerdo a la especificación oficial, el REGEX que representa una dirección de email ortográficamente válida es el siguiente:
/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/

Puse a propósito el término dirección de email ortográficamente válida, porque lo que define una dirección de email realmente válida es que ésta funcione, es decir, que exista y pueda recibir emails.
De ahí se desprende que una verificación por medio de Javascript no es suficiente. Puede ayudarnos a hacer una validación ortográfica, a condición de que Javascript esté activado del lado del cliente.
Si se quiere verificar que el email realmente existe, no hay otra manera que enviando un email y que el destinatario responda. Es a eso a lo que se le puede llamar con toda propiedad validación real de un email.
De hecho, eso es lo que hacen todos los servicios de suscripción serios, nos envían un email que debemos verificar para quedar inscritos definitivamente en sus sitios o en sus listas de distribución.
Me permito mostrar gráficamente los pasos para validar un e-mail. Veremos que lo tratado aquí es apenas la etapa 2 de un proceso de validación que comprendería 5 etapas:

*Etapa 1: El usuario escribe un e-mail

*Etapa 2: Validación ortográfica del e-mail escrito por el usuario

*Etapa 3: Verificar si el dominio correspondiente al e-mail validado ortográficamente posee un servidor de e-mail

*Etapa 4: Enviar una petición (ping) o un email para verificar que el servidor está aceptando e-mails

*Etapa 5: El e-mail fue recibido correctamente en esa dirección y el usuario confirma de algún modo haberlo recibido (haciendo click en un enlace, enviando un email de respuesta, etc)

Hasta que no llegamos a la etapa 5, no podemos decir que el e-mail ha sido validado.

Si todos modos el OP solicita un método de validación que acepte direcciones con ñ y otros caracteres no definidos hasta el momento por la especificación oficial de w3.org (enlace de más arriba), el REGEX mencionado en una anterior respuesta funciona.
El código que sigue es el mismo usado en la pregunta, pero implementando por un lado el REGEX oficial y el REGEX que permite caracteres latinos tales como la ñ.

document.getElementById('email').addEventListener('input', function() {
    campo = event.target;
    valido = document.getElementById('emailOK');

  var reg = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;

 var regOficial = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;

    //Se muestra un texto a modo de ejemplo, luego va a ser un icono
    if (reg.test(campo.value) && regOficial.test(campo.value)) {
      valido.innerText = "válido oficial y extraoficialmente";
    } else if (reg.test(campo.value)) {
      valido.innerText = "válido extraoficialmente";

    } else {
      valido.innerText = "incorrecto";

}
});

    Email:
    <input id="email">

Validación ortográfica en HTML5
HTML5 permite declarar nuestro input del tipo email y se encarga (en parte) de la validación por nosotros, como dice MDN:

email: El atributo representa una dirección de correo electrónico. Los
saltos de línea se eliminan automáticamente del valor ingresado. Puede
ingresarse una dirección de correo no válida, pero el campo de ingreso
sólo funcionará si la dirección  satisface la producción ABNF 1*( atext / "." ) "@" ldh-str 1*( "." ldh-str ) donde atext está definida
en RFC 5322, sección 3.2.3 y ldh-str está definida en RFC 1034, sección 3.5.

Se puede combinar email con el atributo pattern:

pattern : Una expresión regular contra la que el valor es evaluado. El patrón
debe coincidir con el valor completo, no solo una parte. Se puede usar
el atributo title para describir el patrón como ayuda al usuario. Este
atributo aplica cuando el atributo type es text, search, tel, url,
email, o password, y en caso contrario es ignorado. El lenguaje de
expresión regular es el mismo que el algoritmo RegExp de JavaScript,
con el parámetro 'u' que permite tratar al patrón como una secuencia
de código Unicode. El patrón no va rodeado por diagonales.

La desventaja es que no todos los clientes son compatibles con HTML5.

<form>
<input type="email" pattern='^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$' title="Entre un email válido"  placeholder="Entre su email">
<input type="submit" value="Submit">
</form>

A: Según la RFC 6531 se tendrían que soportar más caracteres de a los que estamos acostumbrados. Pero los servidores lo limitan con otras anteriores.
No veo una solución con un rango único que implique introducir "todos los caracteres latinos". A pesar de que parece que van juntos (como en esta tabla del 0080 al 00FF), hay otros por en medio.
Una posible regex para los caracteres latinos que podrían interesarte (fuente) y añadiendo la (sugerencia):
/[A-Za-z\u0021-\u007F\u00C0-\u00D6\u00D8-\u00f6\u00f8-\u00ff]+/g

Se podría juntar con tu regex, las que ya han indicado anteriormente o una según la RFC 2822, como esta, para que no excluya los rangos que te interesan (que hay muchos tipos de tildes) (fuente):
^([^\x00-\x20\x22\x28\x29\x2c\x2e\x3a-\x3c\x3e\x40\x5b-\x5d\x7f-\xff]+|\x22([^\x0d\x22\x5c\x80-\xff]|\x5c[\x00-\x7f])*\x22)(\x2e([^\x00-\x20\x22\x28\x29\x2c\x2e\x3a-\x3c\x3e\x40\x5b-\x5d\x7f-\xff]+|\x22([^\x0d\x22\x5c\x80-\xff]|\x5c[\x00-\x7f])*\x22))*\x40([^\x00-\x20\x22\x28\x29\x2c\x2e\x3a-\x3c\x3e\x40\x5b-\x5d\x7f-\xff]+|\x5b([^\x0d\x5b-\x5d\x80-\xff]|\x5c[\x00-\x7f])*\x5d)(\x2e([^\x00-\x20\x22\x28\x29\x2c\x2e\x3a-\x3c\x3e\x40\x5b-\x5d\x7f-\xff]+|\x5b([^\x0d\x5b-\x5d\x80-\xff]|\x5c[\x00-\x7f])*\x5d))*$